private void processApply(Node operation)
throws ParserConfigurationException, TransformerConfigurationException {
List<Node> targets = getChildNodes(operation, "target");
List<Node> scripts = getChildNodes(operation, "script");
for (int t = 0; t < targets.size(); t++) {
String path = absolutePath(targets.get(t).getTextContent());
NodeList[] operations = new NodeList[scripts.size()];
for (int s = 0; s < scripts.size(); s++) {
operations[s] = scripts.get(s).getChildNodes();
}
apply(path, operations);
}
}
public boolean invokeInboundFaultHandlers() {
for (_i++; _i < _chain.size(); _i++) {
if (!handleFault(_i)) return false;
if (_runtimeException != null) return false;
}
return true;
}
private void processXml(Node operation)
throws ParserConfigurationException, TransformerConfigurationException {
List<Node> targets = getChildNodes(operation, "target");
List<Node> appendOpNodes = getChildNodes(operation, "append");
List<Node> setOpNodes = getChildNodes(operation, "set");
List<Node> replaceOpNodes = getChildNodes(operation, "replace");
List<Node> removeOpNodes = getChildNodes(operation, "remove");
if (targets.isEmpty()) {
return;
}
for (int t = 0; t < targets.size(); t++) {
File target = new File(absolutePath(targets.get(t).getTextContent()));
if (!target.exists()) {
Utils.onError(new Error.FileNotFound(target.getPath()));
return;
}
DocumentBuilder db = DocumentBuilderFactory.newInstance().newDocumentBuilder();
Document doc = null;
try {
doc = db.parse(target);
} catch (Exception ex) {
Utils.onError(new Error.FileParse(target.getPath()));
return;
}
for (int i = 0; i < removeOpNodes.size(); i++) removeXmlEntry(doc, removeOpNodes.get(i));
for (int i = 0; i < replaceOpNodes.size(); i++) replaceXmlEntry(doc, replaceOpNodes.get(i));
for (int i = 0; i < setOpNodes.size(); i++) setXmlEntry(doc, setOpNodes.get(i));
for (int i = 0; i < appendOpNodes.size(); i++) appendXmlEntry(doc, appendOpNodes.get(i));
try {
OutputFormat format = new OutputFormat(doc);
format.setOmitXMLDeclaration(true);
format.setLineWidth(65);
format.setIndenting(true);
format.setIndent(4);
Writer out = new FileWriter(target);
XMLSerializer serializer = new XMLSerializer(out, format);
serializer.serialize(doc);
} catch (IOException e) {
Utils.onError(new Error.WriteXmlConfig(target.getPath()));
}
}
}
/**
* When a message direction is reversed within the chain, this method runs the message backwards
* through the previous handlers. This method should only be invoked when a handler returns false,
* but does not throw any kind of exception.
*/
public boolean uninvokeInbound() throws WebServiceException {
// Set the mandatory properties
_logicalContext.put(MESSAGE_OUTBOUND_PROPERTY, Boolean.TRUE);
_soapContext.put(MESSAGE_OUTBOUND_PROPERTY, Boolean.TRUE);
for (_i++; _i < _chain.size(); _i++) {
boolean success = handleMessage(_i);
if (_protocolException != null) return false;
if (_runtimeException != null) return false;
if (!success) return false;
}
return true;
}
/** Invoke the handler chain for an outbound message. */
public boolean invokeOutbound(Source source, Map<String, DataHandler> attachments)
throws WebServiceException {
_source = source;
// Set the mandatory properties
_logicalContext.put(MESSAGE_OUTBOUND_PROPERTY, Boolean.TRUE);
_soapContext.put(MESSAGE_OUTBOUND_PROPERTY, Boolean.TRUE);
_logicalContext.put(OUTBOUND_MESSAGE_ATTACHMENTS, attachments);
_soapContext.put(OUTBOUND_MESSAGE_ATTACHMENTS, attachments);
for (_i = 0; _i < _chain.size(); _i++) {
boolean success = handleMessage(_i);
if (_protocolException != null) return false;
if (_runtimeException != null) return false;
if (!success) return false;
}
return true;
}
/** Invoke the handler chain for an inbound message. */
public boolean invokeInbound(InputStream in, Map<String, DataHandler> attachments)
throws WebServiceException {
_outbound = false;
_source = null;
try {
DOMResult dom = new DOMResult();
getTransformer().transform(new StreamSource(in), dom);
// XXX The TCK seems to assume a source that will stand up to repeated
// reads... meaning that StreamSource and SAXSource are out, so DOM
// must be what they want.
_source = new DOMSource(dom.getNode());
} catch (Exception e) {
throw new WebServiceException(e);
}
// Set the mandatory properties
_logicalContext.put(MESSAGE_OUTBOUND_PROPERTY, Boolean.FALSE);
_soapContext.put(MESSAGE_OUTBOUND_PROPERTY, Boolean.FALSE);
_logicalContext.put(INBOUND_MESSAGE_ATTACHMENTS, attachments);
_soapContext.put(INBOUND_MESSAGE_ATTACHMENTS, attachments);
// NOTE: the order is reversed for inbound messages
for (_i = _chain.size() - 1; _i >= 0; _i--) {
boolean success = handleMessage(_i);
if (_protocolException != null) return false;
if (_runtimeException != null) return false;
if (!success) return false;
}
return true;
}
public HandlerChainInvoker(List<Handler> chain, BindingProvider bindingProvider) {
_chain = JAXWSUtil.sortHandlerChain(chain);
_invoked = new boolean[_chain.size()];
_bindingProvider = bindingProvider;
}
public void closeClient() {
for (int i = _chain.size() - 1; i >= 0; i--) close(i);
}
public void closeServer() {
for (int i = 0; i < _chain.size(); i++) close(i);
}
private void processTxt(Node operation) {
List<Node> targets = getChildNodes(operation, "target");
List<Node> optionNodes = getChildNodes(operation, "opt");
List<Node> separatorNode = getChildNodes(operation, "separator");
if (targets.isEmpty() || optionNodes.isEmpty()) {
return;
}
String defaultSeparator = "=";
String globalSeparator = defaultSeparator;
if (!separatorNode.isEmpty()) {
globalSeparator = separatorNode.get(0).getTextContent();
if (globalSeparator.length() != 1) {
globalSeparator = defaultSeparator;
}
}
Map<String, String> options = new HashMap<String, String>();
Map<String, String> processedOptions = new HashMap<String, String>();
for (int i = 0; i < optionNodes.size(); i++) {
Node option = optionNodes.get(i);
String name = option.getAttributes().getNamedItem("name").getNodeValue();
String value = option.getTextContent();
if (options.containsKey(name)) {
options.remove(name);
}
options.put(name, value);
}
for (int t = 0; t < targets.size(); t++) {
File target = new File(absolutePath(targets.get(t).getTextContent()));
File tmpFile = new File(Utils.timestamp());
BufferedWriter bw = null;
BufferedReader br = null;
try {
Node separatorAttr = targets.get(t).getAttributes().getNamedItem("separator");
String separator = (separatorAttr == null) ? globalSeparator : separatorAttr.getNodeValue();
if (separator.length() != 1) {
separator = globalSeparator;
}
bw = new BufferedWriter(new FileWriter(tmpFile));
if (target.exists()) {
br = new BufferedReader(new FileReader(target));
for (String line; (line = br.readLine()) != null; ) {
String[] parts = line.split(separator);
if (parts.length < 2) {
bw.write(line);
bw.newLine();
continue;
}
String optName = parts[0].trim();
if (options.containsKey(optName)) {
String optValue = options.get(optName);
bw.write(optName + " " + separator + " " + optValue);
bw.newLine();
processedOptions.put(optName, optValue);
options.remove(optName);
} else if (processedOptions.containsKey(optName)) {
bw.write(optName + " " + separator + " " + processedOptions.get(optName));
bw.newLine();
} else {
bw.write(line);
bw.newLine();
}
}
br.close();
}
for (Map.Entry<String, String> entry : options.entrySet()) {
bw.write(entry.getKey() + " " + separator + " " + entry.getValue());
bw.newLine();
}
bw.close();
FileUtils.copyFile(tmpFile, target);
FileUtils.forceDelete(tmpFile);
} catch (IOException ex) {
Utils.onError(new Error.WriteTxtConfig(target.getPath()));
}
}
}
/**
* Unmarshall a Chromosome instance from a given XML Element representation.
*
* @param a_activeConfiguration current Configuration object
* @param a_xmlElement the XML Element representation of the Chromosome
* @return a new Chromosome instance setup with the data from the XML Element representation
* @throws ImproperXMLException if the given Element is improperly structured or missing data
* @throws UnsupportedRepresentationException if the actively configured Gene implementation does
* not support the string representation of the alleles used in the given XML document
* @throws GeneCreationException if there is a problem creating or populating a Gene instance
* @author Neil Rotstan
* @since 1.0
*/
public static Gene[] getGenesFromElement(
Configuration a_activeConfiguration, Element a_xmlElement)
throws ImproperXMLException, UnsupportedRepresentationException, GeneCreationException {
// Do some sanity checking. Make sure the XML Element isn't null and
// that it in fact represents a set of genes.
// -----------------------------------------------------------------
if (a_xmlElement == null || !(a_xmlElement.getTagName().equals(GENES_TAG))) {
throw new ImproperXMLException(
"Unable to build Chromosome instance from XML Element: "
+ "given Element is not a 'genes' element.");
}
List genes = Collections.synchronizedList(new ArrayList());
// Extract the nested gene elements.
// ---------------------------------
NodeList geneElements = a_xmlElement.getElementsByTagName(GENE_TAG);
if (geneElements == null) {
throw new ImproperXMLException(
"Unable to build Gene instances from XML Element: "
+ "'"
+ GENE_TAG
+ "'"
+ " sub-elements not found.");
}
// For each gene, get the class attribute so we know what class
// to instantiate to represent the gene instance, and then find
// the child text node, which is where the string representation
// of the allele is located, and extract the representation.
// -------------------------------------------------------------
int numberOfGeneNodes = geneElements.getLength();
for (int i = 0; i < numberOfGeneNodes; i++) {
Element thisGeneElement = (Element) geneElements.item(i);
thisGeneElement.normalize();
// Fetch the class attribute and create an instance of that
// class to represent the current gene.
// --------------------------------------------------------
String geneClassName = thisGeneElement.getAttribute(CLASS_ATTRIBUTE);
Gene thisGeneObject;
Class geneClass = null;
try {
geneClass = Class.forName(geneClassName);
try {
Constructor constr = geneClass.getConstructor(new Class[] {Configuration.class});
thisGeneObject = (Gene) constr.newInstance(new Object[] {a_activeConfiguration});
} catch (NoSuchMethodException nsme) {
// Try it by calling method newGeneInternal.
// -----------------------------------------
Constructor constr = geneClass.getConstructor(new Class[] {});
thisGeneObject = (Gene) constr.newInstance(new Object[] {});
thisGeneObject =
(Gene)
PrivateAccessor.invoke(
thisGeneObject, "newGeneInternal", new Class[] {}, new Object[] {});
}
} catch (Throwable e) {
throw new GeneCreationException(geneClass, e);
}
// Find the text node and fetch the string representation of
// the allele.
// ---------------------------------------------------------
NodeList children = thisGeneElement.getChildNodes();
int childrenSize = children.getLength();
String alleleRepresentation = null;
for (int j = 0; j < childrenSize; j++) {
Element alleleElem = (Element) children.item(j);
if (alleleElem.getTagName().equals(ALLELE_TAG)) {
alleleRepresentation = alleleElem.getAttribute("value");
}
if (children.item(j).getNodeType() == Node.TEXT_NODE) {
// We found the text node. Extract the representation.
// ---------------------------------------------------
alleleRepresentation = children.item(j).getNodeValue();
break;
}
}
// Sanity check: Make sure the representation isn't null.
// ------------------------------------------------------
if (alleleRepresentation == null) {
throw new ImproperXMLException(
"Unable to build Gene instance from XML Element: "
+ "value (allele) is missing representation.");
}
// Now set the value of the gene to that reflect the
// string representation.
// -------------------------------------------------
try {
thisGeneObject.setValueFromPersistentRepresentation(alleleRepresentation);
} catch (UnsupportedOperationException e) {
throw new GeneCreationException(
"Unable to build Gene because it does not support the "
+ "setValueFromPersistentRepresentation() method.");
}
// Finally, add the current gene object to the list of genes.
// ----------------------------------------------------------
genes.add(thisGeneObject);
}
return (Gene[]) genes.toArray(new Gene[genes.size()]);
}
