WebSVN – XServices – Path Comparison – /xservices/trunk/src/java/net/brutex/xservices/ws/ Rev HEAD and /xservices/trunk/src/java/net/brutex/xservices/ws Rev 177

Regard whitespace Rev HEAD → Rev 177

 /xservices/trunk/src/java/net/brutex/xservices/ws/XmlService.java
 ,0 → 1,108
+/*
+ *   Copyright 2012 Brian Rosenberger (Brutex Network)
+ *
+ *   Licensed 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 net.brutex.xservices.ws;
+import javax.jws.WebMethod;
+import javax.jws.WebParam;
+import javax.jws.WebService;
+import javax.xml.bind.annotation.XmlElement;
+import net.brutex.xservices.types.AttributeType;
+import net.brutex.xservices.types.NamespaceListType;
+import net.brutex.xservices.types.StringSplitType;
+import net.brutex.xservices.types.ant.FileResource;
+import org.apache.cxf.annotations.WSDLDocumentation;
+import org.apache.shiro.authz.annotation.RequiresPermissions;
+/**
+ * @author Brian Rosenberger, bru(at)brutex.de
+ *
+ */
+@WebService(targetNamespace="http://ws.xservices.brutex.net")
+public abstract interface XmlService
+{
+  public static final String SERVICE_NAME = "XmlService";
+  public static final String OPERATION_APPENDTO = "appendTo";
+  public static final String OPERATION_REPLACE = "replaceNode";
+  public static final String PARAM_XPATH = "xpath";
+  public static final String PARAM_XML = "xmldata";
+  @RequiresPermissions("insertNodes")
+  @WebMethod(operationName="insertNodes")
+  @WSDLDocumentation("Insert an XML fragment into an XML document given as string.")
+  public abstract String insertNodes(
+                  @WebParam(name="sourcexml") String source,
+                  @WebParam(name="encoding") String encoding,
+                  @WebParam(name="namespaceList") NamespaceListType paramNamespaceListType,
+                  @WebParam(name="xpath") @XmlElement(required=true) String paramString1,
+                  @WebParam(name="xmldata") String paramString2)
+    throws XServicesFault;
+  @WebMethod(operationName="insertNodes2")
+  @WSDLDocumentation("Insert an XML fragment into an XML document given as file.")
+  public abstract String insertNodesFromFile(
+                  @WebParam(name="file") FileResource paramFileResource,
+                  @WebParam(name="namespaceList") NamespaceListType paramNamespaceListType,
+                  @WebParam(name="xpath") @XmlElement(required=true) String paramString1,
+                  @WebParam(name="xmldata") String paramString2)
+    throws XServicesFault;
+  @WebMethod(operationName="replaceNodes")
+  @WSDLDocumentation("Replaces matched XML nodes with an XML document given as string.")
+  public abstract String replaceNodes(
+                  @WebParam(name="sourcexml") String source,
+                  @WebParam(name="encoding") String encoding,
+                  @WebParam(name="namespaceList") NamespaceListType paramNamespaceListType,
+                  @WebParam(name="xpath") @XmlElement(required=true) String paramString1,
+                  @WebParam(name="xmldata") String paramString2)
+    throws XServicesFault;
+  @WebMethod(operationName="replaceNodes2")
+  @WSDLDocumentation("Replaces matched XML nodes with an XML document given as file.")
+  public abstract String replaceNodesFromFile(
+                  @WebParam(name="file") FileResource paramFileResource,
+                  @WebParam(name="namespaceList") NamespaceListType paramNamespaceListType,
+                  @WebParam(name="xpath") @XmlElement(required=true) String paramString1,
+                  @WebParam(name="xmldata") String paramString2)
+    throws XServicesFault;
+  @WebMethod(operationName="wrapInCDATA")
+  @WSDLDocumentation("Wraps a String into a CDATA element")
+  public abstract String wrapInCDATA(@WebParam(name="data") @XmlElement(required=true) String data)
+        throws XServicesFault;
+  @WebMethod(operationName="selectXPath")
+  @WSDLDocumentation("Select from xml document given as string using an XPath expression.")
+  public abstract StringSplitType selectXPath(
+                  @WebParam(name="sourcexml") @XmlElement(required=true) String source,
+                  @WebParam(name="encoding") String encoding,
+                  @WebParam(name="namespaceList") NamespaceListType paramNamespaceListType,
+                  @WebParam(name="xpath") @XmlElement(required=true) String paramString1)
+        throws XServicesFault;
+  @WebMethod(operationName="setAttribute")
+  @WSDLDocumentation("Set an attribute.")
+  public abstract String setAttribute(
+                  @WebParam(name="sourcexml") @XmlElement(required=true) String source,
+                  @WebParam(name="encoding") String encoding,
+                  @WebParam(name="namespaceList") NamespaceListType paramNamespaceListType,
+                  @WebParam(name="xpath") @XmlElement(required=true) String paramString1,
+                  @WebParam(name="attribute") @XmlElement(nillable=false, required=true) AttributeType attr)
+        throws XServicesFault;
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /xservices/trunk/src/java/net/brutex/xservices/ws/impl/XmlServiceImpl.java
 ,0 → 1,516
+/*
+ *   Copyright 2013 Brian Rosenberger (Brutex Network)
+ *
+ *   Licensed 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 net.brutex.xservices.ws.impl;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.StringReader;
+import java.io.StringWriter;
+import java.io.UnsupportedEncodingException;
+import java.nio.charset.Charset;
+import java.nio.charset.IllegalCharsetNameException;
+import java.util.Iterator;
+import java.util.List;
+import java.util.StringTokenizer;
+import javax.jws.WebService;
+import javax.ws.rs.NotAuthorizedException;
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLOutputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import javax.xml.stream.XMLStreamWriter;
+import net.brutex.xservices.security.DirectoryPermission;
+import net.brutex.xservices.types.AttributeType;
+import net.brutex.xservices.types.NamespaceListType;
+import net.brutex.xservices.types.NamespaceType;
+import net.brutex.xservices.types.StringSplitType;
+import net.brutex.xservices.types.ant.FileResource;
+import net.brutex.xservices.ws.XServicesFault;
+import net.brutex.xservices.ws.XmlService;
+import org.apache.axiom.om.OMAbstractFactory;
+import org.apache.axiom.om.OMAttribute;
+import org.apache.axiom.om.OMCloneOptions;
+import org.apache.axiom.om.OMComment;
+import org.apache.axiom.om.OMContainer;
+import org.apache.axiom.om.OMDocument;
+import org.apache.axiom.om.OMElement;
+import org.apache.axiom.om.OMFactory;
+import org.apache.axiom.om.OMNode;
+import org.apache.axiom.om.OMProcessingInstruction;
+import org.apache.axiom.om.OMText;
+import org.apache.axiom.om.OMXMLBuilderFactory;
+import org.apache.axiom.om.xpath.AXIOMXPath;
+import org.apache.log4j.Logger;
+import org.apache.shiro.SecurityUtils;
+import org.apache.shiro.authz.UnauthorizedException;
+import org.apache.shiro.authz.annotation.RequiresPermissions;
+import org.jaxen.JaxenException;
+import org.jaxen.SimpleNamespaceContext;
+/**
+ * @author Brian Rosenberger, bru(at)brutex.de
+ *
+ */
+@WebService(targetNamespace = "http://ws.xservices.brutex.net", endpointInterface = "net.brutex.xservices.ws.XmlService", serviceName = "XmlService")
+public class XmlServiceImpl implements XmlService {
+        final Logger logger = Logger.getLogger(XmlServiceImpl.class);
+        public String insertNodesFromFile(FileResource res, NamespaceListType nsList, String xpath, String xmlFragment) throws XServicesFault {
+                try {
+                        AXIOMXPath axp = new AXIOMXPath(xpath);
+                        InputStream is = res.getAntResource(null).getInputStream();
+                        OMDocument sourcedoc = OMXMLBuilderFactory.createOMBuilder(is)
+                                        .getDocument();
+                        OMDocument fragdoc = null;
+                        if ((xmlFragment != null) && (new String(xmlFragment).length() > 0)) {
+                                fragdoc = OMXMLBuilderFactory.createOMBuilder(
+                                                new StringReader("<XS>" + xmlFragment + "</XS>"))
+                                                .getDocument();
+                        } else {
+                                throw new XServicesFault("No xmldata to insert.");
+                        }
+                        // Initialize XPath context
+                        SimpleNamespaceContext context = createContext(nsList);
+                        axp.setNamespaceContext(context);
+                        axp.addNamespaces(fragdoc.getOMDocumentElement());
+                        OMDocument document = insertNodes(sourcedoc, axp, fragdoc);
+                        StringWriter sw = new StringWriter();
+                        XMLOutputFactory xof = XMLOutputFactory.newInstance();
+                        XMLStreamWriter writer = xof.createXMLStreamWriter(sw);
+                        document.serialize(writer);
+                        this.logger.trace(sw.getBuffer().toString());
+                        return sw.getBuffer().toString();
+                } catch (JaxenException e) {
+                        e.printStackTrace();
+                        throw new XServicesFault(e);
+                } catch (IOException e) {
+                        e.printStackTrace();
+                        throw new XServicesFault(e);
+                } catch (XMLStreamException e) {
+                        e.printStackTrace();
+                        throw new XServicesFault(e);
+                }
+        }
+        public String replaceNodesFromFile(FileResource res, NamespaceListType nsList, String xpath, String xmlFragment) throws XServicesFault {
+                try {
+                                AXIOMXPath axp = new AXIOMXPath(xpath);
+                                InputStream is = res.getAntResource(null).getInputStream();
+                                OMDocument sourcedoc = OMXMLBuilderFactory.createOMBuilder(is).getDocument();
+                                OMDocument fragdoc = null;
+                                if ((xmlFragment != null) && (new String(xmlFragment).length() > 0)) {
+                                        fragdoc = OMXMLBuilderFactory.createOMBuilder(
+                                                        new StringReader("<XS>" + xmlFragment + "</XS>"))
+                                                        .getDocument();
+                                } else {
+                                        throw new XServicesFault("No xmldata to insert.");
+                                }
+                                // Initialize XPath context
+                                SimpleNamespaceContext context = createContext(nsList);
+                                axp.setNamespaceContext(context);
+                                axp.addNamespaces(fragdoc.getOMDocumentElement());
+                                OMDocument document = replaceNodes(sourcedoc, axp, fragdoc);
+                                StringWriter sw = new StringWriter();
+                                XMLOutputFactory xof = XMLOutputFactory.newInstance();
+                                XMLStreamWriter writer = xof.createXMLStreamWriter(sw);
+                                document.serialize(writer);
+                                this.logger.trace(sw.getBuffer().toString());
+                                return sw.getBuffer().toString();
+                        } catch (JaxenException e) {
+                                e.printStackTrace();
+                                throw new XServicesFault(e);
+                        } catch (XMLStreamException e) {
+                                e.printStackTrace();
+                                throw new XServicesFault(e);
+                        } catch (IOException e) {
+                                e.printStackTrace();
+                                throw new XServicesFault(e);
+                        }
+        }
+        public String replaceNodes(String source, String encoding, NamespaceListType nsList, String xpath, String xmlFragment) throws XServicesFault {
+                encoding = validateEncoding(encoding);
+                try {
+                        AXIOMXPath axp = new AXIOMXPath(xpath);
+                        InputStream is = new ByteArrayInputStream(source.getBytes(encoding));
+                        OMDocument sourcedoc = OMXMLBuilderFactory.createOMBuilder(is)
+                                        .getDocument();
+                        OMDocument fragdoc = null;
+                        if ((xmlFragment != null) && (new String(xmlFragment).length() > 0)) {
+                                fragdoc = OMXMLBuilderFactory.createOMBuilder(
+                                                new StringReader("<XS>" + xmlFragment + "</XS>"))
+                                                .getDocument();
+                        } else {
+                                throw new XServicesFault("No xmldata to insert.");
+                        }
+                        // Initialize XPath context
+                        SimpleNamespaceContext context = createContext(nsList);
+                        axp.setNamespaceContext(context);
+                        axp.addNamespaces(fragdoc.getOMDocumentElement());
+                        OMDocument document = replaceNodes(sourcedoc, axp, fragdoc);
+                        StringWriter sw = new StringWriter();
+                        XMLOutputFactory xof = XMLOutputFactory.newInstance();
+                        XMLStreamWriter writer = xof.createXMLStreamWriter(sw);
+                        document.serialize(writer);
+                        this.logger.trace(sw.getBuffer().toString());
+                        return sw.getBuffer().toString();
+                } catch (JaxenException e) {
+                        e.printStackTrace();
+                        throw new XServicesFault(e);
+                } catch (XMLStreamException e) {
+                        e.printStackTrace();
+                        throw new XServicesFault(e);
+                } catch (UnsupportedEncodingException e) {
+                        throw new XServicesFault(e);
+                }
+        }
+        @RequiresPermissions("insertNodes")
+        public String insertNodes(String source, String encoding, NamespaceListType nsList, String xpath, String xmlFragment) throws XServicesFault {
+                encoding = validateEncoding(encoding);
+                try {
+                        AXIOMXPath axp = new AXIOMXPath(xpath);
+                        InputStream is = new ByteArrayInputStream(source.getBytes(encoding));
+                        OMDocument sourcedoc = OMXMLBuilderFactory.createOMBuilder(is)
+                                        .getDocument();
+                        OMDocument fragdoc = null;
+                        if ((xmlFragment != null) && (new String(xmlFragment).length() > 0)) {
+                                fragdoc = OMXMLBuilderFactory.createOMBuilder(
+                                                new StringReader("<XS>" + xmlFragment + "</XS>"))
+                                                .getDocument();
+                        } else {
+                                throw new XServicesFault("No xmldata to insert.");
+                        }
+                        // Initialize XPath context
+                        SimpleNamespaceContext context = createContext(nsList);
+                        axp.setNamespaceContext(context);
+                        axp.addNamespaces(fragdoc.getOMDocumentElement());
+                        OMDocument document = insertNodes(sourcedoc, axp, fragdoc);
+                        StringWriter sw = new StringWriter();
+                        XMLOutputFactory xof = XMLOutputFactory.newInstance();
+                        XMLStreamWriter writer = xof.createXMLStreamWriter(sw);
+                        document.serialize(writer);
+                        this.logger.trace(sw.getBuffer().toString());
+                        return sw.getBuffer().toString();
+                } catch (JaxenException e) {
+                        e.printStackTrace();
+                        throw new XServicesFault(e);
+                } catch (XMLStreamException e) {
+                        e.printStackTrace();
+                        throw new XServicesFault(e);
+                } catch (UnsupportedEncodingException e) {
+                        throw new XServicesFault(e);
+                }
+        }
+        public String wrapInCDATA(String data) throws XServicesFault {
+                String result ="";
+                String[] tokens = data.split("\\]\\]>", -1);
+                for(int i=0; i<tokens.length; i++) {
+                        result +=  tokens[i];
+                        if (i+1 < tokens.length ) result += "]]]]><![CDATA[>";
+                }
+                result = "<![CDATA[" + result + "]]>";
+                return result;
+        }
+        public StringSplitType selectXPath(String source, String encoding, NamespaceListType nsList, String xpath) throws XServicesFault {
+                encoding = validateEncoding(encoding);
+                try {
+                        StringSplitType rarray = new StringSplitType();
+                        AXIOMXPath axp = new AXIOMXPath(xpath);
+                        InputStream is = new ByteArrayInputStream(source.getBytes(encoding));
+                        OMDocument sourcedoc = OMXMLBuilderFactory.createOMBuilder(is).getDocument();
+                        // Initialize XPath context
+                        SimpleNamespaceContext context = createContext(nsList);
+                        axp.setNamespaceContext(context);
+                        List results = axp.selectNodes(sourcedoc);
+                        for(Object o : results) {
+                                String text = null;
+                                if(o instanceof OMNode) {
+                                        switch (((OMNode)o).getType()) {
+                                                case OMNode.TEXT_NODE:
+                                                        text = ((OMText)o).getText();
+                                                        break;
+                                                case OMNode.COMMENT_NODE:
+                                                        text = ((OMComment)o).getValue();
+                                                        break;
+                                                case OMNode.PI_NODE:
+                                                        text = ((OMProcessingInstruction)o).getValue();
+                                                        break;
+                                                default:
+                                                        StringWriter sw = new StringWriter();
+                                                        XMLOutputFactory xof = XMLOutputFactory.newInstance();
+                                                        XMLStreamWriter writer = xof.createXMLStreamWriter(sw);
+                                                        ((OMNode)o).serialize(writer);
+                                                        writer.flush();
+                                                        text = sw.toString();
+                                        }
+                                } else if(o instanceof OMAttribute) {
+                                        text = ((OMAttribute)o).getAttributeValue();
+                                } else {
+                                        text = String.valueOf(o);
+                                }
+                                rarray.addStringMatch(text);
+                        }
+                        return rarray;
+                        } catch (JaxenException e) {
+                        e.printStackTrace();
+                        throw new XServicesFault(e);
+                } catch (XMLStreamException e) {
+                                // TODO Auto-generated catch block
+                        throw new XServicesFault(e.getMessage());
+                        } catch (UnsupportedEncodingException e) {
+                                throw new XServicesFault(e);
+                }
+        }
+        public String setAttribute(String source, String encoding, NamespaceListType nsList, String xpath, AttributeType attr) throws XServicesFault {
+                encoding = validateEncoding(encoding);
+                try {
+                        StringSplitType rarray = new StringSplitType();
+                        AXIOMXPath axp = new AXIOMXPath(xpath);
+                        InputStream is = new ByteArrayInputStream(source.getBytes(encoding));
+                        OMDocument sourcedoc = OMXMLBuilderFactory.createOMBuilder(is).getDocument();
+                        OMFactory fac = OMAbstractFactory.getOMFactory();
+                        // Initialize XPath context
+                        SimpleNamespaceContext context = createContext(nsList);
+                        axp.setNamespaceContext(context);
+                        List results = axp.selectNodes(sourcedoc);
+                        for(Object o : results) {
+                                String text = null;
+                                if(o instanceof OMNode) {
+                                        switch (((OMNode)o).getType()) {
+                                                case OMNode.ELEMENT_NODE:
+                                                        OMElement node = ((OMElement)o);
+                                                        if(attr.value == null) {
+                                                                node.removeAttribute( node.getAttribute(new QName(attr.name)));
+                                                        } else {
+                                                                node.addAttribute(attr.name, attr.value, node.getNamespace());
+                                                        }
+                                                        break;
+                                                default:
+                                                        throw new XServicesFault("XPath expression did not match an element node.");
+                                        }
+                                } else {
+                                        throw new XServicesFault("XPath expression did not match a node.");
+                                }
+                        }
+                        StringWriter sw = new StringWriter();
+                        XMLOutputFactory xof = XMLOutputFactory.newInstance();
+                        XMLStreamWriter writer = xof.createXMLStreamWriter(sw);
+                        sourcedoc.serialize(writer);
+                        writer.flush();
+                        return sw.toString();
+                        } catch (JaxenException e) {
+                        e.printStackTrace();
+                        throw new XServicesFault(e);
+                } catch (XMLStreamException e) {
+                                // TODO Auto-generated catch block
+                        throw new XServicesFault(e.getMessage());
+                        } catch (UnsupportedEncodingException e) {
+                                throw new XServicesFault(e);
+                }
+        }
+        private OMDocument insertNodes(OMDocument xmldocument, AXIOMXPath axp,OMDocument xmlfragment) throws XServicesFault {
+                List<?> olist = null;
+                try {
+                        olist = axp.selectNodes(xmldocument.getOMDocumentElement());
+                        this.logger.debug("XPath '" + axp.toString() + "' has "
+                                        + olist.size() + " matches.");
+                        this.logger.trace("XPath root expression is: '" + axp.debug()
+                                        + "'.");
+                } catch (JaxenException e) {
+                        throw new XServicesFault(e.getMessage(), e);
+                }
+                if (olist.size() == 0)
+                        throw new XServicesFault(Messages.getString("XmlService.no_match",
+                                        new Object[] { axp.toString() }));
+                // Prepare children to insert
+                xmlfragment.build();
+                // Determine what has been matched
+                OMContainer match = null;
+                for (Object o : olist) {
+                        Iterator<?> children = xmlfragment.getOMDocumentElement()
+                                        .getChildren();
+                        if ((o instanceof OMNode)) {
+                                OMNode node = (OMNode) o;
+                                switch (node.getType()) {
+                                case OMNode.ELEMENT_NODE:
+                                        if ((o instanceof OMElement))
+                                                match = (OMElement) o;
+                                        if ((o instanceof OMDocument))
+                                                match = ((OMDocument) o).getOMDocumentElement();
+                                        this.logger.debug(Messages.getString("XmlService.8"));
+                                        break;
+                                case OMNode.TEXT_NODE:
+                                        match = ((OMText) o).getParent();
+                                        this.logger.debug(Messages.getString("XmlService.9"));
+                                        break;
+                                case OMNode.COMMENT_NODE:
+                                        // match = node.getParent();
+                                        match = (OMContainer) node;
+                                        this.logger.debug(Messages.getString("XmlService.10"));
+                                        break;
+                                default:
+                                        this.logger.error("XPath matched "
+                                                        + o.getClass().getCanonicalName() + " Node Type:"
+                                                        + node.getType());
+                                        this.logger.error(Messages.getString("XmlService.11"));
+                                        throw new XServicesFault(
+                                                        Messages.getString("XmlService.12"));
+                                }
+                        } else {
+                                this.logger.error("XPath matched "
+                                                + o.getClass().getCanonicalName());
+                                this.logger.error(Messages.getString("XmlService.11"));
+                                throw new XServicesFault(Messages.getString("XmlService.12"));
+                        }
+                        while (children.hasNext()) {
+                                OMNode container = (OMNode) children.next();
+                                match.addChild((OMNode) container.clone(new OMCloneOptions()));
+                        }
+                }
+                xmldocument.build();
+                return xmldocument;
+        }
+        private OMDocument replaceNodes(OMDocument xmldocument, AXIOMXPath axp, OMDocument xmlfragment) throws XServicesFault {
+                List<?> olist = null;
+                try {
+                        olist = axp.selectNodes(xmldocument.getOMDocumentElement());
+                        this.logger.debug("XPath '" + axp.toString() + "' has "
+                                        + olist.size() + " matches.");
+                        this.logger.trace("XPath root expression is: '" + axp.debug()
+                                        + "'.");
+                } catch (JaxenException e) {
+                        throw new XServicesFault(e.getMessage(), e);
+                }
+                if (olist.size() == 0)
+                        throw new XServicesFault(Messages.getString("XmlService.no_match",
+                                        new Object[] { axp.toString() }));
+                // Prepare children to insert
+                xmlfragment.build();
+                // Determine what has been matched
+                OMNode match = null;
+                for (Object o : olist) {
+                        Iterator<?> children = xmlfragment.getOMDocumentElement()
+                                        .getChildren();
+                        if ((o instanceof OMNode)) {
+                                OMNode node = (OMNode) o;
+                                switch (node.getType()) {
+                                case OMNode.ELEMENT_NODE:
+                                        if ((o instanceof OMElement))
+                                                match = (OMElement) o;
+                                        if ((o instanceof OMDocument))
+                                                match = ((OMDocument) o).getOMDocumentElement();
+                                        this.logger.debug(Messages.getString("XmlService.8"));
+                                        break;
+                                default:
+                                        this.logger.error("XPath matched "
+                                                        + o.getClass().getCanonicalName() + " Node Type:"
+                                                        + node.getType());
+                                        this.logger.error(Messages.getString("XmlService.11"));
+                                        throw new XServicesFault(
+                                                        Messages.getString("XmlService.12"));
+                                }
+                        } else {
+                                this.logger.error("XPath matched "
+                                                + o.getClass().getCanonicalName());
+                                this.logger.error(Messages.getString("XmlService.11"));
+                                throw new XServicesFault(Messages.getString("XmlService.12"));
+                        }
+                        while (children.hasNext()) {
+                                OMNode container = (OMNode) children.next();
+                                match.insertSiblingBefore((OMNode) container.clone(new OMCloneOptions()));
+                        }
+                        match.detach();
+                }
+                xmldocument.build();
+                return xmldocument;
+        }
+        private SimpleNamespaceContext createContext(NamespaceListType nsList) {
+                // Initialize XPath context
+                SimpleNamespaceContext context = new SimpleNamespaceContext();
+                if(nsList != null) {
+                        for (NamespaceType ns : nsList.getNamespaces()) {
+                                context.addNamespace(ns.getPrefix(), ns.getUri().toString());
+                                this.logger.debug(Messages.getString("XmlService.0")
+                                                + ns.getPrefix() + "=\"" + ns.getUri().toString()
+                                                + "\"'");
+                        }
+                } else {
+                        logger.debug("No namespaces defined.");
+                }
+                return context;
+        }
+        private String validateEncoding(String encoding) throws XServicesFault {
+                if(encoding == null || encoding.equals("")) { encoding=Charset.defaultCharset().displayName(); }
+                try {
+                        Charset.isSupported(encoding);
+                } catch (IllegalCharsetNameException e) {
+                        throw new XServicesFault("Endcoding '"+encoding+"' is not supported by this JRE.");
+                }
+                logger.debug("Setting source xml string encoding to '"+encoding+"'");
+                return encoding;
+        }
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /xservices/trunk/src/java/net/brutex/xservices/ws/impl/ExecuteServiceImpl.java
 ,0 → 1,341
+/*
+ *   Copyright 2010 Brian Rosenberger (Brutex Network)
+ *
+ *   Licensed 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 net.brutex.xservices.ws.impl;
+import java.io.File;
+import javax.jws.WebMethod;
+import javax.jws.WebParam;
+import javax.jws.WebService;
+import net.brutex.xservices.types.HostConnection;
+import net.brutex.xservices.types.ReturnCode;
+import net.brutex.xservices.util.BrutexNamespaces;
+import net.brutex.xservices.util.RunTask;
+import net.brutex.xservices.ws.ExecuteService;
+import net.brutex.xservices.ws.XServicesFault;
+import org.apache.tools.ant.taskdefs.ExecTask;
+import org.apache.tools.ant.taskdefs.optional.net.RExecTask;
+import org.apache.tools.ant.taskdefs.optional.net.TelnetTask;
+import org.apache.tools.ant.taskdefs.optional.ssh.SSHExec;
+import org.apache.tools.ant.types.Commandline;
+import org.mozilla.javascript.Context;
+import org.mozilla.javascript.Scriptable;
+/**
+ *
+ * @author Brian Rosenberger, bru@brutex.de
+ */
+@WebService(targetNamespace = BrutexNamespaces.WS_XSERVICES, endpointInterface = "net.brutex.xservices.ws.ExecuteService", serviceName = "ExecuteService")
+public class ExecuteServiceImpl implements ExecuteService {
+        /*
+         * (non-Javadoc)
+         *
+         * @see
+         * net.brutex.xservices.ws.impl.ExecuteService#runCommand(java.lang.String,
+         * java.lang.String, long)
+         */
+        @WebMethod(operationName = "runCommand")
+        public ReturnCode runCommand(@WebParam(name = "executable") String cmd,
+                        @WebParam(name = "argline") String args,
+                        @WebParam(name = "timeout") long timeout) {
+                return executeCommand(cmd, Commandline.translateCommandline(args),
+                                null, false, null, false, true, false, timeout);
+        }
+        /*
+         * (non-Javadoc)
+         *
+         * @see
+         * net.brutex.xservices.ws.impl.ExecuteService#runCommandWithArgs(java.lang
+         * .String, java.lang.String[], long)
+         */
+        @WebMethod(operationName = "runCommandWithArgs")
+        public ReturnCode runCommandWithArgs(
+                        @WebParam(name = "executable") String cmd,
+                        @WebParam(name = "arg") String[] args,
+                        @WebParam(name = "timeout") long timeout) {
+                return executeCommand(cmd, args, null, false, null, false, true, false,
+                                timeout);
+        }
+        /*
+         * (non-Javadoc)
+         *
+         * @see
+         * net.brutex.xservices.ws.impl.ExecuteService#runCommandAsync(java.lang
+         * .String, java.lang.String)
+         */
+        @WebMethod(operationName = "runCommandAsync")
+        public ReturnCode runCommandAsync(
+                        @WebParam(name = "executable") String cmd,
+                        @WebParam(name = "argline") String args) {
+                return executeCommand(cmd, Commandline.translateCommandline(args),
+                                null, true, null, false, true, false, 0);
+        }
+        /*
+         * (non-Javadoc)
+         *
+         * @see
+         * net.brutex.xservices.ws.impl.ExecuteService#runCommandAsyncWithArgs(java
+         * .lang.String, java.lang.String[])
+         */
+        @WebMethod(operationName = "runCommandAsyncWithArgs")
+        public ReturnCode runCommandAsyncWithArgs(
+                        @WebParam(name = "executable") String cmd,
+                        @WebParam(name = "arg") String[] args) {
+                return executeCommand(cmd, args, null, true, null, false, true, false,
+);
+        }
+        /*
+         * (non-Javadoc)
+         *
+         * @see
+         * net.brutex.xservices.ws.impl.ExecuteService#runCommandWithSSH(java.lang
+         * .String, int, java.lang.String, java.lang.String, java.lang.String, long)
+         */
+        @WebMethod(operationName = "runCommandWithSSH")
+        public ReturnCode runCommandWithSSH(
+                        @WebParam(name = "host") HostConnection host,
+                        @WebParam(name = "command") String cmd,
+                        @WebParam(name = "timeout") long timeout) {
+                return sshExec(host.hostname, host.user, host.password, host.port, cmd,
+                                timeout);
+        }
+        /*
+         * (non-Javadoc)
+         *
+         * @see
+         * net.brutex.xservices.ws.impl.ExecuteService#runCommandWithSSHKeyAuth(
+         * java.lang.String, int, java.lang.String, java.lang.String,
+         * java.lang.String, java.lang.String, long)
+         */
+        @WebMethod(operationName = "runCommandWithSSHKeyAuth")
+        public ReturnCode runCommandWithSSHKeyAuth(
+                        @WebParam(name = "host") HostConnection host,
+                        @WebParam(name = "keyfile") String keyfile,
+                        @WebParam(name = "command") String cmd,
+                        @WebParam(name = "timeout") long timeout) {
+                return sshExecWithCert(host.hostname, host.user, host.password,
+                                keyfile, host.port, cmd, timeout);
+        }
+        /*
+         * (non-Javadoc)
+         *
+         * @see
+         * net.brutex.xservices.ws.impl.ExecuteService#rExec(net.brutex.xservices
+         * .types.HostConnection, java.lang.String, long)
+         */
+        @WebMethod(operationName = "rExec")
+        public ReturnCode rExec(@WebParam(name = "host") HostConnection host,
+                        @WebParam(name = "command") String cmd,
+                        @WebParam(name = "timeout") long timeout) {
+                return rexec(host.hostname, host.port, host.user, host.password, cmd,
+                                timeout);
+        }
+        /*
+         * (non-Javadoc)
+         *
+         * @see
+         * net.brutex.xservices.ws.impl.ExecuteService#runTelnet(net.brutex.xservices
+         * .types.HostConnection, java.lang.String, java.lang.String,
+         * java.lang.String, long)
+         */
+        @WebMethod(operationName = "telnet")
+        public ReturnCode runTelnet(@WebParam(name = "host") HostConnection host,
+                        @WebParam(name = "prompt") String prompt,
+                        @WebParam(name = "command") String cmd,
+                        @WebParam(name = "expect") String expect,
+                        @WebParam(name = "timeout") long timeout) {
+                return telnet(host.hostname, host.port, host.user, host.password, cmd,
+                                timeout, prompt, expect);
+        }
+        public void runJScript(String script) throws XServicesFault {
+                try {
+                        // Create and enter a Context. A Context stores information about
+                        // the execution environment of a script.
+                        Context cx = Context.enter();
+                        cx.setOptimizationLevel(0);
+                        cx.setLanguageVersion(Context.VERSION_1_7);
+                        // cx is the Context instance you're using to run scripts
+                        /*
+                         * cx.setClassShutter(new ClassShutter() { public boolean
+                         * visibleToScripts(String className) {
+                         * if(className.startsWith("adapter")) return true;
+                         * if(className.startsWith("java.lang.System") ||
+                         * className.startsWith
+                         * ("org.apache.tomcat.util.log.SystemLogHandler")) return true;
+                         * System.out.println(className + " is blocked."); return false; }
+                         * });
+                         */
+                        // Initialise the standard objects (Object, Function, etc.). This
+                        // must be done before scripts can be
+                        // executed. The null parameter tells initStandardObjects
+                        // to create and return a scope object that we use
+                        // in later calls.
+                        Scriptable scope = cx.initStandardObjects();
+                        // Object wrappedOut = Context.javaToJS(System.out, scope);
+                        // Object wrappedOut2 = Context.javaToJS(this, scope);
+                        // scope.put("out", scope, wrappedOut);
+                        // scope.put("exe", scope, wrappedOut2);
+                        // Execute the script
+                        // cx.evaluateString(scope, "importClass('java.lang.System');\n",
+                        // "head", 1, null);
+                        // cx.evaluateString(scope, "importPackage('java.util');\n", "head",
+                        // 2, null);
+                        Object obj = cx
+                                        .evaluateString(scope, script, "TestScript", 1, null);
+                } catch (Exception e) {
+                        System.out.println(e.getMessage());
+                } finally {
+                        // Exit the Context. This removes the association between the
+                        // Context and the current thread and is an
+                        // essential cleanup action. There should be a call to exit for
+                        // every call to enter.
+                        Context.exit();
+                }
+        }
+        @WebMethod(exclude = true)
+        private ReturnCode executeCommand(String executable, String[] args,
+                        File dir, boolean spawn, String inputstring,
+                        boolean newenvironment, boolean vmlauncher, boolean searchpath,
+                        long timeout) {
+                ExecTask exe = new ExecTask();
+                RunTask runner = new RunTask(exe);
+                /*
+                 * Commandline cmdl = new Commandline(); cmdl.setExecutable(executable);
+                 * cmdl.addArguments(args); System.out.println(cmdl.describeCommand());
+                 */
+                exe.setExecutable(executable);
+                for (String s : args) {
+                        exe.createArg().setValue(s);
+                }
+                exe.setDir(dir);
+                if (spawn) {
+                        exe.setSpawn(spawn);
+                } else {
+                        exe.setTimeout(timeout);
+                        exe.setInputString(inputstring);
+                        exe.setOutputproperty("ExecuteService.stdout");
+                        exe.setErrorProperty("ExecuteService.stderr");
+                        exe.setResultProperty("ExecuteService.result");
+                }
+                exe.setNewenvironment(newenvironment);
+                exe.setVMLauncher(vmlauncher);
+                exe.setSearchPath(searchpath);
+                return runner.postTask();
+        }
+        @WebMethod(exclude = true)
+        private ReturnCode sshExec(String host, String username, String password,
+                        int port, String command, long timeout) {
+                SSHExec sshexec = new SSHExec();
+                RunTask runner = new RunTask(sshexec);
+                sshexec.setHost(host);
+                sshexec.setUsername(username);
+                sshexec.setPassword(password);
+                sshexec.setPort(port);
+                sshexec.setCommand(command);
+                sshexec.setTrust(true);
+                sshexec.setTimeout(timeout);
+                sshexec.setOutputproperty("SSHExec.stdout");
+                return runner.postTask();
+        }
+        @WebMethod(exclude = true)
+        private ReturnCode sshExecWithCert(String host, String username,
+                        String passphrase, String keyfile, int port, String command,
+                        long timeout) {
+                SSHExec sshexec = new SSHExec();
+                RunTask runner = new RunTask(sshexec);
+                sshexec.setHost(host);
+                sshexec.setUsername(username);
+                sshexec.setKeyfile(keyfile);
+                sshexec.setPassphrase(passphrase);
+                sshexec.setPort(port);
+                sshexec.setCommand(command);
+                sshexec.setTrust(true);
+                sshexec.setTimeout(timeout);
+                sshexec.setOutputproperty("SSHExec.stdout");
+                return runner.postTask();
+        }
+        @WebMethod(exclude = true)
+        private ReturnCode rexec(String host, int port, String username,
+                        String password, String command, long timeout) {
+                RExecTask rexec = new RExecTask();
+                RunTask runner = new RunTask(rexec);
+                rexec.setServer(host);
+                rexec.setPort(port);
+                rexec.setUserid(username);
+                rexec.setPassword(password);
+                rexec.setCommand(command);
+                rexec.setTimeout((int) Math.round(timeout));
+                return runner.postTask();
+        }
+        @WebMethod(exclude = true)
+        private ReturnCode telnet(String host, int port, String username,
+                        String password, String command, long timeout, String prompt,
+                        String expect) {
+                TelnetTask rexec = new TelnetTask();
+                RunTask runner = new RunTask(rexec);
+                rexec.setServer(host);
+                rexec.setPort(port);
+                rexec.setUserid(username);
+                rexec.setPassword(password);
+                rexec.setTimeout((int) Math.round(timeout));
+                rexec.createRead().addText(prompt);
+                rexec.createWrite().addText(command);
+                rexec.createRead().addText(expect);
+                return runner.postTask();
+        }
+}

 /xservices/trunk/src/java/net/brutex/xservices/ws/impl/StringServiceImpl.java
 ,0 → 1,131
+/*
+ *   Copyright 2013 Brian Rosenberger (Brutex Network)
+ *
+ *   Licensed 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 net.brutex.xservices.ws.impl;
+import java.util.ArrayList;
+import java.util.StringTokenizer;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import javax.jws.WebService;
+import net.brutex.xservices.types.StringMatchType;
+import net.brutex.xservices.types.StringReplaceType;
+import net.brutex.xservices.types.StringSplitType;
+import net.brutex.xservices.ws.StringService;
+import net.brutex.xservices.ws.XServicesFault;
+import org.apache.commons.lang3.StringEscapeUtils;
+import org.apache.commons.lang3.text.translate.CharSequenceTranslator;
+import org.apache.commons.lang3.text.translate.NumericEntityEscaper;
+/**
+ * @author Brian Rosenberger, bru(at)brutex.de
+ *
+ */
+@WebService(targetNamespace="http://ws.xservices.brutex.net", endpointInterface="net.brutex.xservices.ws.StringService", serviceName="StringService")
+public class StringServiceImpl
+  implements StringService
+{
+  public StringReplaceType replaceRegEx(String res, String search, String replace, String flags)
+    throws XServicesFault
+  {
+    try
+    {
+      int allflags = getFlags(flags);
+      Pattern pattern = Pattern.compile(search, allflags);
+      Matcher matcher = pattern.matcher(res);
+      int count = 0;
+      while (matcher.find()) {
+        count++;
+      }
+      if (flags.contains("g")) {
+        return new StringReplaceType(matcher.replaceAll(replace), count);
+      }
+      if (count > 1)
+        count = 1;
+      return new StringReplaceType(matcher.replaceFirst(replace),
+        count);
+    }
+    catch (Exception e) {
+      throw new XServicesFault(e);
+    }
+  }
+  public StringMatchType matchRegEx(String res, String search, String flags)
+    throws XServicesFault
+  {
+    int allflags = getFlags(flags);
+    Pattern pattern = Pattern.compile(search, allflags);
+    Matcher matcher = pattern.matcher(res);
+    StringMatchType rm = new StringMatchType();
+        for (int i=0; i <= matcher.groupCount(); i++) {
+                while(matcher.find()) {
+                        rm.addStringMatch(matcher.start(i), matcher.end(i), "group-"+i, matcher.group(i));
+                }
+                matcher.reset();
+         }
+    return rm;
+  }
+  public String encodeToXMLEntities(String res)
+    throws XServicesFault
+  {
+    StringEscapeUtils fac = new StringEscapeUtils();
+    StringEscapeUtils.ESCAPE_XML.with(new CharSequenceTranslator[] { NumericEntityEscaper.between(128, 2147483647) });
+    return StringEscapeUtils.escapeXml(res);
+  }
+  public StringSplitType splitString(String paramString, String delimiter) throws XServicesFault {
+                StringTokenizer tk = new StringTokenizer(paramString, delimiter);
+                StringSplitType result = new StringSplitType();
+                while(tk.hasMoreTokens()) {
+                        result.addStringMatch( tk.nextToken() );
+                }
+                return result;
+        }
+  @Override
+        public String removeCRLF(String paramString) throws XServicesFault {
+                String value = paramString.replaceAll("[\r\n]", "");
+                return value;
+        }
+  private int getFlags(String flags) {
+    int allflags = 0;
+    if (flags.contains("i")) {
+      allflags += 2;
+    }
+    if (flags.contains("m")) {
+      allflags += 8;
+    }
+    if (flags.contains("u")) {
+      allflags += 64;
+    }
+    if (flags.contains("s")) {
+      allflags += 32;
+    }
+    if (flags.contains("d")) {
+      allflags++;
+    }
+    if (flags.contains("x")) {
+      allflags += 4;
+    }
+    return allflags;
+  }
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /xservices/trunk/src/java/net/brutex/xservices/ws/impl/DateServiceImpl.java
 ,0 → 1,202
+/*
+ *   Copyright 2011 Brian Rosenberger (Brutex Network)
+ *
+ *   Licensed 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 net.brutex.xservices.ws.impl;
+import java.math.BigInteger;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.List;
+import java.util.TimeZone;
+import javax.jws.WebService;
+import net.brutex.xservices.types.DateFormatType;
+import net.brutex.xservices.types.DateInfoExtendedType;
+import net.brutex.xservices.types.DateInfoType;
+import net.brutex.xservices.types.DateTimeUnits;
+import net.brutex.xservices.types.TimeZoneType;
+import net.brutex.xservices.util.BrutexNamespaces;
+import net.brutex.xservices.ws.DateService;
+import net.brutex.xservices.ws.XServicesFault;
+/**
+ * @author Brian Rosenberger
+ *
+ */
+@WebService(targetNamespace = BrutexNamespaces.WS_XSERVICES, endpointInterface = "net.brutex.xservices.ws.DateService", serviceName = DateService.SERVICE_NAME)
+public class DateServiceImpl implements DateService {
+        private static String ERR_INVALIDFORMAT = "Invalid format pattern.";
+        private static String ERR_INVALIDTIMEZONE = "Invalid timezone.";
+        public DateInfoType getDate() throws XServicesFault {
+                GregorianCalendar c = new GregorianCalendar();
+                DateInfoType dateinfo = new DateInfoType(c, TimeZone.getDefault());
+                return dateinfo;
+        }
+        public DateInfoExtendedType getDateExtended() throws XServicesFault {
+                GregorianCalendar c = new GregorianCalendar();
+                DateInfoExtendedType dateinfo = new DateInfoExtendedType(c,
+                                TimeZone.getDefault());
+                return dateinfo;
+        }
+        public BigInteger getTimestamp() {
+                Date d = new Date();
+                long l = d.getTime();
+                return new BigInteger(Long.toString(l));
+        }
+        public BigInteger getTimestamp2() {
+                Date d = new Date();
+                long l = d.getTime() / 1000;
+                return new BigInteger(Long.toString(l));
+        }
+        public String getInTimezone(Date date, String timezone)
+                        throws XServicesFault {
+                if (!isValidTimezone(timezone))
+                        throw new XServicesFault(ERR_INVALIDTIMEZONE);
+                TimeZone targetzone = TimeZone.getTimeZone(timezone);
+                String targetstring = DateFormatType.ISO8601.format(date, null, targetzone);
+                return targetstring;
+        }
+        public String formatDate(Date cal, DateFormatType format)
+                        throws XServicesFault {
+                return format.format(cal, null, null);
+        }
+        public String formatDateAdvanced(Date cal, String format)
+                        throws XServicesFault {
+                String result = null;
+                SimpleDateFormat f = new SimpleDateFormat(format);
+                result = f.format(cal);
+                return result;
+        }
+        public Date parseDate(String s, DateFormatType format, String timezone)
+                        throws XServicesFault {
+                if (timezone == null | timezone.equals(""))
+                        timezone = TimeZone.getDefault().getID();
+                if (!isValidTimezone(timezone))
+                        throw new XServicesFault(ERR_INVALIDTIMEZONE);
+                try {
+                        return format.parse(s, null, TimeZone.getTimeZone(timezone));
+                } catch (ParseException e) {
+                        throw new XServicesFault(e);
+                }
+        }
+        public GregorianCalendar parseDateAdvanced(String s, String format,
+                        String timezone) throws XServicesFault {
+                SimpleDateFormat f = null;
+                Date date = null;
+                if (timezone == null | timezone.equals(""))
+                        timezone = TimeZone.getDefault().getID();
+                if (!isValidTimezone(timezone))
+                        throw new XServicesFault(ERR_INVALIDTIMEZONE);
+                try {
+                        f = new SimpleDateFormat(format);
+                        date = f.parse(s);
+                } catch (IllegalArgumentException e) {
+                        throw new XServicesFault(ERR_INVALIDFORMAT + e.getMessage());
+                } catch (ParseException e) {
+                        throw new XServicesFault("Cannot parse date: " + e.getMessage());
+                }
+                GregorianCalendar cal = new GregorianCalendar();
+                cal.setTimeZone(TimeZone.getTimeZone(timezone));
+                cal.setTime(date);
+                return cal;
+        }
+        public BigInteger dateTimeDiff(Date fromCal, Date toCal)
+                        throws XServicesFault {
+                long diff = toCal.getTime() - fromCal.getTime();
+                BigInteger d = new BigInteger(String.valueOf(diff), 10);
+                return d;
+        }
+        public BigInteger dateTimeDiff2(Date fromCal, Date toCal, DateTimeUnits unit)
+                        throws XServicesFault {
+                BigInteger d = dateTimeDiff(fromCal, toCal);
+                switch (unit) {
+                case SECONDS:
+                        d = d.divide(new BigInteger("1000"));
+                        break;
+                case MINUTES:
+                        d = d.divide(new BigInteger("60000"));
+                        break;
+                case HOURS:
+                        d = d.divide(new BigInteger("3600000"));
+                        break;
+                case DAYS:
+                        d = d.divide(new BigInteger("86400000"));
+                        break;
+                case YEARS:
+                        d = d.divide(new BigInteger("31536000000"));
+                        break;
+                }
+                return d;
+        }
+        public GregorianCalendar dateAdd(GregorianCalendar cal, BigInteger value,
+                        DateTimeUnits unit) throws XServicesFault {
+                switch (unit) {
+                case SECONDS:
+                        cal.add(GregorianCalendar.SECOND, value.intValue());
+                        break;
+                case MINUTES:
+                        cal.add(GregorianCalendar.MINUTE, value.intValue());
+                        break;
+                case HOURS:
+                        cal.add(GregorianCalendar.HOUR_OF_DAY, value.intValue());
+                        break;
+                case DAYS:
+                        cal.add(GregorianCalendar.DAY_OF_MONTH, value.intValue());
+                        break;
+                case YEARS:
+                        cal.add(GregorianCalendar.YEAR, value.intValue());
+                        break;
+                default:
+                        cal.add(GregorianCalendar.MILLISECOND, value.intValue());
+                }
+                return cal;
+        }
+        private boolean isValidTimezone(String id) {
+                boolean yes = false;
+                for (String s : TimeZone.getAvailableIDs()) {
+                        if (s.equals(id)) {
+                                yes = true;
+                                break;
+                        }
+                }
+                return yes;
+        }
+        public List<TimeZoneType> getTimezones() {
+                List<TimeZoneType> output = new ArrayList<TimeZoneType>();
+                for (String s : TimeZone.getAvailableIDs()) {
+                        output.add(new TimeZoneType(TimeZone.getTimeZone(s)));
+                }
+                return output;
+        }
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /xservices/trunk/src/java/net/brutex/xservices/ws/impl/FileServiceImpl.java
 ,0 → 1,371
+/*
+ *   Copyright 2010 Brian Rosenberger (Brutex Network)
+ *
+ *   Licensed 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 net.brutex.xservices.ws.impl;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+import javax.activation.DataHandler;
+import javax.jws.WebMethod;
+import javax.jws.WebParam;
+import javax.jws.WebService;
+import net.brutex.xservices.types.ReplacePattern;
+import net.brutex.xservices.types.ReturnCode;
+import net.brutex.xservices.types.ant.ArchiveResource;
+import net.brutex.xservices.types.ant.AttachmentType;
+import net.brutex.xservices.types.ant.FileResource;
+import net.brutex.xservices.types.ant.FileSetResource;
+import net.brutex.xservices.util.BrutexNamespaces;
+import net.brutex.xservices.util.RunTask;
+import net.brutex.xservices.ws.FileService;
+import net.brutex.xservices.ws.XServicesFault;
+import org.apache.cxf.aegis.type.mtom.StreamDataSource;
+import org.apache.tools.ant.BuildException;
+import org.apache.tools.ant.taskdefs.Basename;
+import org.apache.tools.ant.taskdefs.Chmod;
+import org.apache.tools.ant.taskdefs.Copy;
+import org.apache.tools.ant.taskdefs.Echo;
+import org.apache.tools.ant.taskdefs.LoadResource;
+import org.apache.tools.ant.taskdefs.Replace;
+import org.apache.tools.ant.taskdefs.optional.ReplaceRegExp;
+import org.apache.tools.ant.taskdefs.optional.unix.Chgrp;
+import org.apache.tools.ant.taskdefs.optional.unix.Chown;
+import org.apache.tools.ant.types.FileSet;
+/**
+ *
+ * @author Brian Rosenberger, bru@brutex.de
+ */
+@WebService(targetNamespace = BrutexNamespaces.WS_XSERVICES, endpointInterface = "net.brutex.xservices.ws.FileService", serviceName = "FileService")
+public class FileServiceImpl implements FileService {
+        /*
+         * (non-Javadoc)
+         *
+         * @see net.brutex.xservices.ws.impl.FileService#basename(java.lang.String,
+         * java.lang.String)
+         */
+        public String basename(String filename, String suffix) {
+                final String BASENAME_VALUE = "basename.value";
+                Basename basename = new Basename();
+                RunTask runner = new RunTask(basename);
+                basename.setFile(new File(filename));
+                if (suffix != null && !suffix.equals("")) {
+                        basename.setSuffix(suffix);
+                }
+                basename.setProperty(BASENAME_VALUE);
+                ReturnCode r = runner.postTask();
+                return r.getProperty(BASENAME_VALUE);
+        }
+        public ReturnCode replaceInFile(FileResource res, String search,
+                        String replace) throws XServicesFault {
+                ReturnCode r = null;
+                Replace rep = new Replace();
+                rep.setTaskName("Replace");
+                RunTask runner = new RunTask(rep);
+                rep.addConfigured(res.getAntResource(rep.getProject()));
+                rep.setToken(search);
+                rep.setValue(replace);
+                try {
+                        r = runner.postTask();
+                } catch (BuildException e) {
+                        throw new XServicesFault(e);
+                }
+                return r;
+        }
+        public ReturnCode replaceInFile2(FileResource res,
+                        List<ReplacePattern> patternList) throws XServicesFault {
+                ReturnCode r = null;
+                for (ReplacePattern pat : patternList) {
+                        Replace rep = new Replace();
+                        rep.setTaskName("Replace");
+                        RunTask runner = new RunTask(rep);
+                        rep.addConfigured(res.getAntResource(rep.getProject()));
+                        rep.setToken(pat.search);
+                        rep.setValue(pat.replace);
+                        try {
+                                r = runner.postTask();
+                        } catch (BuildException e) {
+                                throw new XServicesFault(e);
+                        }
+                }
+                return r;
+        }
+        public ReturnCode replaceInFileRegEx(FileResource res, String search,
+                        String replace, String flags) throws XServicesFault {
+                ReplaceRegExp rep = new ReplaceRegExp();
+                rep.setTaskName("ReplaceRegExp");
+                RunTask runner = new RunTask(rep);
+                File infile = new File(res.uri);
+                rep.setFile(infile);
+                rep.setMatch(search);
+                rep.setReplace(replace);
+                rep.setFlags(flags);
+                try {
+                        ReturnCode r = runner.postTask();
+                        return r;
+                } catch (BuildException e) {
+                        throw new XServicesFault(e);
+                }
+        }
+        /*
+         * (non-Javadoc)
+         *
+         * @see
+         * net.brutex.xservices.ws.impl.FileService#base64Encode(net.brutex.xservices
+         * .types.FileSetResource)
+         */
+        public AttachmentType downloadFile(FileResource res) throws XServicesFault {
+                InputStream is = null;
+                try {
+                        is = res.getAntResource(null).getInputStream();
+                        StreamDataSource ssource = new StreamDataSource(
+                                        "application/binary", is);
+                        DataHandler h = new DataHandler(ssource);
+                        AttachmentType t = new AttachmentType();
+                        t.setContent(h);
+                        t.setFilename(res.getAntResource(null).getName());
+                        return t;
+                } catch (IOException e) {
+                        throw new XServicesFault(e);
+                }
+        }
+        /*
+         * (non-Javadoc)
+         *
+         * @see
+         * net.brutex.xservices.ws.impl.FileService#base64Decode(net.brutex.xservices
+         * .types.AttachmentType)
+         */
+        public String uploadFile(AttachmentType file) throws XServicesFault {
+                DataHandler h = file.getContent();
+                File f = new File(file.getFilename());
+                FileOutputStream fout;
+                try {
+                        fout = new FileOutputStream(f);
+                        h.writeTo(fout);
+                        fout.flush();
+                        fout.close();
+                } catch (FileNotFoundException e) {
+                        throw new XServicesFault(e);
+                } catch (IOException e) {
+                        throw new XServicesFault(e);
+                }
+                return file.getFilename();
+        }
+        /*
+         * (non-Javadoc)
+         *
+         * @see
+         * net.brutex.xservices.ws.impl.FileService#copy(net.brutex.xservices.types
+         * .FileSetResource, java.lang.String, boolean, boolean, java.lang.String)
+         */
+        public ReturnCode copy(FileSetResource src, String todir, boolean plm,
+                        boolean overwrite, String encoding) throws XServicesFault {
+                Copy copy = new Copy();
+                copy.setTaskName("Copy");
+                RunTask runner = new RunTask(copy);
+                FileSet set = src.getAntResource(copy.getProject());
+                copy.add(set);
+                File dst = new File(todir);
+                if (dst.isDirectory()) {
+                        copy.setTodir(dst);
+                }
+                if (dst.isFile()) {
+                        copy.setTofile(dst);
+                }
+                copy.setOverwrite(overwrite);
+                copy.setPreserveLastModified(plm);
+                if (encoding != null && !encoding.equals("")) {
+                        copy.setOutputEncoding(encoding);
+                } else {
+                        copy.setOutputEncoding(System.getProperty("file.encoding"));
+                }
+                return runner.postTask();
+        }
+        public ReturnCode copyFile(String fromFile, String tofile, boolean overwrite)
+                        throws XServicesFault {
+                Copy copy = new Copy();
+                copy.setTaskName("Copy");
+                RunTask runner = new RunTask(copy);
+                File f = new File(fromFile);
+                if (!f.isFile())
+                        throw new XServicesFault("File '" + fromFile + "' not found.");
+                copy.setFile(new File(fromFile));
+                copy.setTofile(new File(tofile));
+                copy.setOverwrite(overwrite);
+                return runner.postTask();
+        }
+        /*
+         * (non-Javadoc)
+         *
+         * @see
+         * net.brutex.xservices.ws.impl.FileService#loadRes(net.brutex.xservices
+         * .types.FileResource, java.lang.String)
+         */
+        public String loadRes(FileResource res, String encoding)
+                        throws XServicesFault {
+                if (encoding == null || encoding.equals("")) {
+                        encoding = System.getProperty("file.encoding");
+                }
+                LoadResource lr = new LoadResource();
+                lr.setTaskName("LoadResource");
+                RunTask runner = new RunTask(lr);
+                lr.addConfigured(res.getAntResource(lr.getProject()));
+                lr.setEncoding(encoding);
+                System.out.println("Using encoding: " + encoding);
+                lr.setProperty("LoadResource.out");
+                ReturnCode r = runner.postTask();
+                return r.getProperty("LoadResource.out");
+        }
+        /*
+         * (non-Javadoc)
+         *
+         * @see
+         * net.brutex.xservices.ws.impl.FileService#loadResFromArchive(net.brutex
+         * .xservices.types.ArchiveResource, java.lang.String)
+         */
+        public String loadResFromArchive(ArchiveResource res, String encoding) {
+                if (encoding == null || encoding.equals("")) {
+                        encoding = System.getProperty("file.encoding");
+                }
+                LoadResource lr = new LoadResource();
+                lr.setTaskName("LoadResource");
+                RunTask runner = new RunTask(lr);
+                lr.addConfigured(res.getAntResource(lr.getProject()));
+                lr.setEncoding(encoding);
+                System.out.println("Using encoding: " + encoding);
+                lr.setProperty("LoadResource.out");
+                ReturnCode r = runner.postTask();
+                return r.getProperty("LoadResource.out");
+        }
+        /*
+         * (non-Javadoc)
+         *
+         * @see net.brutex.xservices.ws.impl.FileService#echo2file(java.lang.String,
+         * java.lang.String, java.lang.String, boolean)
+         */
+        public ReturnCode echo2file(String message, String file, String encoding,
+                        boolean append, boolean create) throws XServicesFault {
+                Echo echo = new Echo();
+                echo.setTaskName("toFile");
+                RunTask runTask = new RunTask(echo);
+                echo.addText(message);
+                echo.setEncoding(encoding);
+                File f = new File(file);
+                try {
+                        if(!f.exists() && create) f.createNewFile();
+                        if (!f.canWrite())
+                                throw new XServicesFault("Cannot write to file: "
+                                                + f.getCanonicalPath());
+                        echo.setFile(f);
+                        echo.setAppend(append);
+                        ReturnCode c = runTask.postTask();
+                        return c;
+                } catch (BuildException e) {
+                        throw new XServicesFault("Error in echo2file.", e);
+                } catch (IOException e) {
+                        throw new XServicesFault("Cannot write to file." + e.getMessage(), e);
+                }
+        }
+        /*
+         * (non-Javadoc)
+         *
+         * @see
+         * net.brutex.xservices.ws.impl.FileService#changeOwner(net.brutex.xservices
+         * .types.FileSetResource, java.lang.String)
+         */
+        public ReturnCode changeOwner(FileSetResource res, String owner) {
+                Chown chown = new Chown();
+                chown.setTaskName("Chown");
+                RunTask runner = new RunTask(chown);
+                chown.setOwner(owner);
+                FileSet set = res.getAntResource(chown.getProject());
+                chown.add(set);
+                chown.setMaxParallel(300);
+                return runner.postTask();
+        }
+        /*
+         * (non-Javadoc)
+         *
+         * @see
+         * net.brutex.xservices.ws.impl.FileService#changeGroup(net.brutex.xservices
+         * .types.FileSetResource, java.lang.String)
+         */
+        public ReturnCode changeGroup(FileSetResource res, String group) {
+                Chgrp chgrp = new Chgrp();
+                chgrp.setTaskName("Chgrp");
+                RunTask runner = new RunTask(chgrp);
+                chgrp.setGroup(group);
+                FileSet set = res.getAntResource(chgrp.getProject());
+                chgrp.add(set);
+                chgrp.setMaxParallel(300);
+                return runner.postTask();
+        }
+        /*
+         * (non-Javadoc)
+         *
+         * @see
+         * net.brutex.xservices.ws.impl.FileService#changeMode(net.brutex.xservices
+         * .types.FileSetResource, java.lang.String)
+         */
+        public ReturnCode changeMode(FileSetResource res, String perm) {
+                Chmod chmod = new Chmod();
+                chmod.setTaskName("Chmod");
+                RunTask runner = new RunTask(chmod);
+                FileSet set = res.getAntResource(chmod.getProject());
+                chmod.add(set);
+                chmod.setMaxParallel(300);
+                chmod.setPerm(perm);
+                chmod.setVerbose(true);
+                return runner.postTask();
+        }
+}

 /xservices/trunk/src/java/net/brutex/xservices/ws/impl/messages.properties
 ,0 → 1,11
+XmlService.0=Adding name space to XPath context: 'xmlns:
+XmlService.10=XPath did match a comment node
+XmlService.11=XPath did match a not supported node
+XmlService.12=XPath did match a not supported node
+XmlService.13=XPath did not match a node.
+XmlService.14=XPath did not match a node.
+XmlService.adding_namespace=Adding name space to XPath context: 'xmlns:{0}="{1}"
+XmlService.8=XPath did match an element node
+XmlService.9=XPath did match a text node
+XmlService.no_match=XPath "{0}" did not match anything.
+XmlService.null_or_empty=Nothing to append!
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /xservices/trunk/src/java/net/brutex/xservices/ws/impl/ArchiveServiceImpl.java
 ,0 → 1,324
+/*
+ *   Copyright 2010 Brian Rosenberger (Brutex Network)
+ *
+ *   Licensed 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 net.brutex.xservices.ws.impl;
+import java.io.File;
+import javax.jws.WebMethod;
+import javax.jws.WebParam;
+import javax.jws.WebService;
+import net.brutex.xservices.types.CompressionType;
+import net.brutex.xservices.types.ReturnCode;
+import net.brutex.xservices.types.ant.ArchiveResource;
+import net.brutex.xservices.types.ant.FileResource;
+import net.brutex.xservices.types.ant.ResourceInterface;
+import net.brutex.xservices.util.BrutexNamespaces;
+import net.brutex.xservices.util.RunTask;
+import net.brutex.xservices.util.UnRarTask;
+import net.brutex.xservices.ws.ArchiveService;
+import org.apache.tools.ant.taskdefs.BUnzip2;
+import org.apache.tools.ant.taskdefs.BZip2;
+import org.apache.tools.ant.taskdefs.Expand;
+import org.apache.tools.ant.taskdefs.GUnzip;
+import org.apache.tools.ant.taskdefs.GZip;
+import org.apache.tools.ant.taskdefs.Untar;
+import org.apache.tools.ant.taskdefs.Zip;
+/**
+ *
+ * @author Brian Rosenberger, bru@brutex.de
+ */
+@WebService(targetNamespace = BrutexNamespaces.WS_XSERVICES,
+                endpointInterface="net.brutex.xservices.ws.ArchiveService",
+                serviceName = "ArchiveService")
+public class ArchiveServiceImpl implements ArchiveService {
+    /* (non-Javadoc)
+         * @see net.brutex.xservices.ws.ArchiveService#bzip2(net.brutex.xservices.types.FileResource, java.lang.String)
+         */
+        @WebMethod(operationName = WS_OPERATION_BZIP2, action = WS_OPERATION_BZIP2)
+    public ReturnCode bzip2(@WebParam(name = WS_PARAM_SOURCEFILE) FileResource src,
+            @WebParam(name = WS_PARAM_DESTFILE) String file) {
+        return bzip(src, new File(file));
+    }
+    /* (non-Javadoc)
+         * @see net.brutex.xservices.ws.ArchiveService#bzip2FromArchive(net.brutex.xservices.types.ArchiveResource, java.lang.String)
+         */
+        @WebMethod(operationName = WS_OPERATION_BZIP2_ARCHIVE, action = WS_OPERATION_BZIP2_ARCHIVE)
+   public ReturnCode bzip2FromArchive(@WebParam(name = WS_PARAM_SOURCEARCHIVE) ArchiveResource src,
+            @WebParam(name = WS_PARAM_DESTFILE) String file) {
+return null;//       return bzip(src, new File(file));
+    }
+    /* (non-Javadoc)
+         * @see net.brutex.xservices.ws.ArchiveService#gzip(net.brutex.xservices.types.FileResource, java.lang.String)
+         */
+        @WebMethod(operationName = WS_OPERATION_GZIP, action = WS_OPERATION_GZIP)
+    public ReturnCode gzip(@WebParam(name = WS_PARAM_SOURCEFILE) FileResource src,
+            @WebParam(name = WS_PARAM_DESTFILE) String file) {
+        return gzip(src, new File(file));
+    }
+    /* (non-Javadoc)
+         * @see net.brutex.xservices.ws.ArchiveService#gzipFromArchive(net.brutex.xservices.types.ArchiveResource, java.lang.String)
+         */
+        @WebMethod(operationName = WS_OPERATION_GZIP_ARCHIVE, action = WS_OPERATION_GZIP_ARCHIVE)
+    public ReturnCode gzipFromArchive(@WebParam(name = WS_PARAM_SOURCEARCHIVE) ArchiveResource src,
+            @WebParam(name = WS_PARAM_DESTFILE) String file) {
+        return gzip(src, new File(file));
+    }
+    /* (non-Javadoc)
+         * @see net.brutex.xservices.ws.ArchiveService#gunzip(java.lang.String, java.lang.String)
+         */
+        @WebMethod(operationName = WS_OPERATION_GUNZIP, action = WS_OPERATION_GUNZIP)
+    public ReturnCode gunzip(@WebParam(name = WS_PARAM_SOURCEFILE_STRING) String src,
+            @WebParam(name = WS_PARAM_DESTDIR) String dest) {
+        File target = null;
+        if (!dest.equals("") && dest != null) {
+            target = new File(dest);
+        }
+        return GUnzip(new FileResource(FileResource.Type.FILE, src), target);
+    }
+    /* (non-Javadoc)
+         * @see net.brutex.xservices.ws.ArchiveService#bunzip2(java.lang.String, java.lang.String)
+         */
+        @WebMethod(operationName = WS_OPERATION_BUNZIP2)
+    public ReturnCode bunzip2(@WebParam(name = WS_PARAM_SOURCEFILE_STRING) String src,
+            @WebParam(name = WS_PARAM_DESTDIR) String dest) {
+        File target = null;
+        if (!dest.equals("") && dest != null) {
+            target = new File(dest);
+        }
+        return BUnzip2(new FileResource(FileResource.Type.FILE, src), target);
+    }
+    /* (non-Javadoc)
+         * @see net.brutex.xservices.ws.ArchiveService#gunzipFromURL(java.lang.String, java.lang.String)
+         */
+        @WebMethod(operationName = "gunzipFromURL")
+    public ReturnCode gunzipFromURL(@WebParam(name = WS_PARAM_SOURCEURL) String src,
+            @WebParam(name = WS_PARAM_DESTDIR) String dest) {
+        File target = null;
+        if (!dest.equals("") && dest != null) {
+            target = new File(dest);
+        }
+        return GUnzip(new FileResource(FileResource.Type.URL, src), target);
+    }
+    /* (non-Javadoc)
+         * @see net.brutex.xservices.ws.ArchiveService#bunzip2FromURL(java.lang.String, java.lang.String)
+         */
+        @WebMethod(operationName = "bunzip2FromURL")
+    public ReturnCode bunzip2FromURL(@WebParam(name = WS_PARAM_SOURCEURL) String src,
+            @WebParam(name = WS_PARAM_DESTDIR) String dest) {
+        File target = null;
+        if (!dest.equals("") && dest != null) {
+            target = new File(dest);
+        }
+        return BUnzip2(new FileResource(FileResource.Type.URL, src), target);
+    }
+    /* (non-Javadoc)
+         * @see net.brutex.xservices.ws.ArchiveService#zip(net.brutex.xservices.types.FileResource, java.lang.String, boolean, java.lang.String, int)
+         */
+        @WebMethod(operationName = "zip")
+    public ReturnCode zip(@WebParam(name = WS_PARAM_SOURCEFILE) FileResource src,
+            @WebParam(name = WS_PARAM_DESTFILE) String file,
+            @WebParam(name = WS_PARAM_OVERWRITE) boolean overwrite,
+            @WebParam(name = WS_PARAM_ENCODING) String encoding,
+            @WebParam(name = "compresslevel") int level) {
+        if (level > 9) {
+            level = 9;
+        }
+        if (level < 0) {
+            level = 0;
+        }
+        return zip(src, new File(file), encoding, !overwrite, level);
+    }
+    /* (non-Javadoc)
+         * @see net.brutex.xservices.ws.ArchiveService#zipFromArchive(net.brutex.xservices.types.ArchiveResource, java.lang.String, boolean, java.lang.String, int)
+         */
+        @WebMethod(operationName = "zipFromArchive")
+    public ReturnCode zipFromArchive(@WebParam(name = WS_PARAM_SOURCEARCHIVE) ArchiveResource src,
+            @WebParam(name = WS_PARAM_DESTFILE) String file,
+            @WebParam(name = WS_PARAM_OVERWRITE) boolean update,
+            @WebParam(name = WS_PARAM_ENCODING) String encoding,
+            @WebParam(name = "compresslevel") int level) {
+        return zip(src, new File(file), encoding, !update, level);
+    }
+    /* (non-Javadoc)
+         * @see net.brutex.xservices.ws.ArchiveService#unzip(java.lang.String, java.lang.String, boolean, java.lang.String)
+         */
+        @WebMethod(operationName = "unzip")
+    public ReturnCode unzip(@WebParam(name = WS_PARAM_SOURCEFILE_STRING) String src,
+            @WebParam(name = WS_PARAM_DESTDIR) String dest,
+            @WebParam(name = WS_PARAM_OVERWRITE) boolean overwrite,
+            @WebParam(name = WS_PARAM_ENCODING) String encoding) {
+        return unzip(new File(src), new File(dest), overwrite, encoding);
+    }
+    /* (non-Javadoc)
+         * @see net.brutex.xservices.ws.ArchiveService#unrar(java.lang.String, java.lang.String)
+         */
+        @WebMethod(operationName = "unrar")
+    public ReturnCode unrar(@WebParam(name = WS_PARAM_SOURCEFILE_STRING) String src,
+            @WebParam(name = WS_PARAM_DESTDIR) String dest) {
+        return unrar(new File(src), new File(dest));
+    }
+    /* (non-Javadoc)
+         * @see net.brutex.xservices.ws.ArchiveService#untar(java.lang.String, java.lang.String, boolean, net.brutex.xservices.types.CompressionType)
+         */
+        @WebMethod(operationName = "untar")
+    public ReturnCode untar(@WebParam(name = WS_PARAM_SOURCEFILE_STRING) String src,
+            @WebParam(name = WS_PARAM_DESTDIR) String dest,
+            @WebParam(name = WS_PARAM_OVERWRITE) boolean overwrite,
+            @WebParam(name = "compression") CompressionType compression) {
+        Untar.UntarCompressionMethod c = new Untar.UntarCompressionMethod();
+        switch (compression) {
+            case GZIP:
+                c.setValue("gzip");
+                break;
+            case BZIP2:
+                c.setValue("bzip2");
+                break;
+            default:
+                c.setValue("none");
+                break;
+        }
+        return untar(new File(src), new File(dest), overwrite, c);
+    }
+    @WebMethod(exclude = true)
+    private ReturnCode bzip(ResourceInterface src, File dst) {
+        if (dst.exists() && dst.isFile()) {
+            dst.delete();
+        }
+        BZip2 bzip = new BZip2();
+        bzip.setTaskName("BZip2");
+        RunTask runner = new RunTask(bzip);
+        bzip.setSrcResource(src.getAntResource(bzip.getProject()));
+        bzip.setDestfile(dst);
+        return runner.postTask();
+    }
+    @WebMethod(exclude = true)
+    private ReturnCode gzip(ResourceInterface src, File dst) {
+        if (dst.exists() && dst.isFile()) {
+            dst.delete();
+        }
+        GZip gzip = new GZip();
+        gzip.setTaskName("GZip");
+        RunTask runner = new RunTask(gzip);
+        gzip.addConfigured(src.getAntResource(gzip.getProject()));
+        gzip.setDestfile(dst);
+        return runner.postTask();
+    }
+    @WebMethod(exclude = true)
+    private ReturnCode zip(ResourceInterface src, File dst, String encoding, boolean update, int compresslevel) {
+        Zip zip = new Zip();
+        zip.setTaskName("Zip");
+        RunTask runner = new RunTask(zip);
+        zip.add(src.getAntResource(zip.getProject()));
+        zip.setDestFile(dst);
+        if (encoding != null && !encoding.equals("")) {
+            zip.setEncoding(encoding);
+        }
+        zip.setUpdate(update);
+        zip.setLevel(compresslevel);
+        return runner.postTask();
+    }
+    @WebMethod(exclude = true)
+    private ReturnCode GUnzip(ResourceInterface src, File dst) {
+        GUnzip uz = new GUnzip();
+        uz.setTaskName("GUnzip");
+        RunTask runner = new RunTask(uz);
+        uz.setSrcResource(src.getAntResource(uz.getProject()));
+        if (dst != null) {
+            uz.setDest(dst);
+        }
+        return runner.postTask();
+    }
+    @WebMethod(exclude = true)
+    private ReturnCode BUnzip2(ResourceInterface src, File dst) {
+        BUnzip2 uz = new BUnzip2();
+        uz.setTaskName("BUnzip2");
+        RunTask runner = new RunTask(uz);
+        uz.setSrcResource(src.getAntResource(uz.getProject()));
+        if (dst != null) {
+            uz.setDest(dst);
+        }
+        return runner.postTask();
+    }
+    @WebMethod(exclude = true)
+    private ReturnCode unzip(File src, File dest, boolean overwrite, String encoding) {
+        Expand unzip = new Expand();
+        unzip.setTaskName("UnZip");
+        RunTask runner = new RunTask(unzip);
+        unzip.setSrc(src);
+        unzip.setDest(dest);
+        unzip.setOverwrite(overwrite);
+        if (encoding != null && !encoding.equals("")) {
+            unzip.setEncoding(encoding);
+        }
+        return runner.postTask();
+    }
+    @WebMethod(exclude = true)
+    private ReturnCode untar(File src, File dest, boolean overwrite, Untar.UntarCompressionMethod compression) {
+        Untar unzip = new Untar();
+        unzip.setTaskName("Untar");
+        RunTask runner = new RunTask(unzip);
+        unzip.setSrc(src);
+        unzip.setDest(dest);
+        unzip.setOverwrite(overwrite);
+        unzip.setCompression(compression);
+        return runner.postTask();
+    }
+    @WebMethod(exclude = true)
+    private ReturnCode unrar(File src, File dst) {
+        UnRarTask unrar = new UnRarTask();
+        unrar.setTaskName("UnRar");
+        RunTask runner = new RunTask(unrar);
+        unrar.setSrc(src);
+        unrar.setDst(dst);
+        return runner.postTask();
+    }
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /xservices/trunk/src/java/net/brutex/xservices/ws/impl/StorageServiceImpl.java
 ,0 → 1,56
+/*
+ *   Copyright 2011 Brian Rosenberger (Brutex Network)
+ *
+ *   Licensed 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 net.brutex.xservices.ws.impl;
+import javax.jws.WebService;
+import net.brutex.xservices.types.TargetNodeType;
+import net.brutex.xservices.types.ant.AttachmentType;
+import net.brutex.xservices.types.ant.CollectionType;
+import net.brutex.xservices.util.BrutexNamespaces;
+import net.brutex.xservices.ws.StorageService;
+import net.brutex.xservices.ws.XServicesFault;
+/**
+ * @author Brian Rosenberger
+ * @since 0.5.0
+ *
+ */
+@WebService(targetNamespace = BrutexNamespaces.WS_XSERVICES, endpointInterface = "net.brutex.xservices.ws.StorageService", serviceName = StorageService.SERVICE_NAME)
+public class StorageServiceImpl implements StorageService {
+        public String storeText(String text) throws XServicesFault {
+                // TODO Auto-generated method stub
+                return null;
+        }
+        public String storeBinary(AttachmentType binary) throws XServicesFault {
+                // TODO Auto-generated method stub
+                return null;
+        }
+        public String createCollection(CollectionType collection)
+                        throws XServicesFault {
+                return collection.getUuid();
+        }
+        public void deliverCollection(CollectionType collection,
+                        TargetNodeType targetnode, boolean isFiring) throws XServicesFault {
+                // TODO Auto-generated method stub
+        }
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /xservices/trunk/src/java/net/brutex/xservices/ws/impl/Messages.java
 ,0 → 1,44
+/*
+ *   Copyright 2013 Brian Rosenberger (Brutex Network)
+ *
+ *   Licensed 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 net.brutex.xservices.ws.impl;
+import java.text.MessageFormat;
+import java.util.MissingResourceException;
+import java.util.ResourceBundle;
+public class Messages
+{
+  private static final String BUNDLE_NAME = "net.brutex.xservices.ws.impl.messages";
+  private static final ResourceBundle RESOURCE_BUNDLE = ResourceBundle.getBundle("net.brutex.xservices.ws.impl.messages");
+  public static String getString(String key)
+  {
+    try
+    {
+      return RESOURCE_BUNDLE.getString(key); } catch (MissingResourceException e) {
+    }
+    return '!' + key + '!';
+  }
+  public static String getString(String key, Object[] params)
+  {
+    try {
+      return MessageFormat.format(RESOURCE_BUNDLE.getString(key), params); } catch (MissingResourceException e) {
+    }
+    return '!' + key + '!';
+  }
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /xservices/trunk/src/java/net/brutex/xservices/ws/impl/MiscServiceImpl.java
 ,0 → 1,153
+/*
+ *   Copyright 2013 Brian Rosenberger (Brutex Network)
+ *
+ *   Licensed 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 net.brutex.xservices.ws.impl;
+import java.util.Enumeration;
+import java.util.Properties;
+import java.util.UUID;
+import javax.jws.WebService;
+import net.brutex.xservices.types.HostConnection;
+import net.brutex.xservices.types.HostinfoType;
+import net.brutex.xservices.types.MailMimeType;
+import net.brutex.xservices.types.ReturnCode;
+import net.brutex.xservices.types.RuntimeInfoType;
+import net.brutex.xservices.types.ant.FileSetResource;
+import net.brutex.xservices.util.BrutexNamespaces;
+import net.brutex.xservices.util.RunTask;
+import net.brutex.xservices.ws.MiscService;
+import org.apache.cxf.annotations.WSDLDocumentation;
+import org.apache.cxf.annotations.WSDLDocumentationCollection;
+import org.apache.tools.ant.taskdefs.HostInfo;
+import org.apache.tools.ant.taskdefs.Sleep;
+import org.apache.tools.ant.taskdefs.email.EmailTask;
+/**
+ * Implements the web service
+ *
+ * @author Brian Rosenberger, bru@brutex.de
+ */
+@WebService(targetNamespace="http://ws.xservices.brutex.net", endpointInterface="net.brutex.xservices.ws.MiscService", serviceName="MiscService")
+public class MiscServiceImpl
+  implements MiscService
+{
+  public HostinfoType getHostinfo(String hostname)
+  {
+    HostInfo info = new HostInfo();
+    info.setTaskName("HostInfo");
+    RunTask runner = new RunTask(info);
+    info.setHost(hostname);
+    ReturnCode ret = runner.postTask();
+    HostinfoType infotype = new HostinfoType(
+      ret.getProperty("NAME"),
+      ret.getProperty("DOMAIN"),
+      ret.getProperty("ADDR4"),
+      ret.getProperty("ADDR6"));
+    return infotype;
+  }
+  public ReturnCode getInfo() {
+    ReturnCode r = new ReturnCode();
+    r.returnCode = 0;
+    Properties props = System.getProperties();
+    Enumeration e = props.propertyNames();
+    while (e.hasMoreElements())
+    {
+      String propName = (String)e.nextElement();
+      String propValue = (String)props.get(propName);
+      r.stdOut = (r.stdOut + propName + ": " + propValue + "\n");
+    }
+    return r;
+  }
+  public ReturnCode sendMailSimple(HostConnection mailhost, String from, String tolist, String subject, String message)
+  {
+    return sendMail(from, from, tolist, "", "", subject, message,
+      "text/plain", null, mailhost.hostname, mailhost.port,
+      mailhost.user, mailhost.password, "utf-8", false, false);
+  }
+  public ReturnCode sendMailSimpleWithAttachment(HostConnection mailhost, String from, String tolist, String subject, String message, FileSetResource res)
+  {
+    return sendMail(from, from, tolist, "", "", subject, message,
+      "text/plain", res, mailhost.hostname, mailhost.port,
+      mailhost.user, mailhost.password, "utf-8", false, false);
+  }
+  public ReturnCode sendMail(HostConnection mailhost, String from, String tolist, String cclist, String bcclist, String subject, MailMimeType mimetype, String charset, String message, FileSetResource res, boolean ssl, boolean tls)
+  {
+    return sendMail(from, from, tolist, cclist, bcclist, subject, message,
+      mimetype.value(), res, mailhost.hostname, mailhost.port,
+      mailhost.user, mailhost.password, charset, tls, ssl);
+  }
+  public ReturnCode sleep(int minutes, int seconds) {
+    return sleep(0, minutes, seconds, 0);
+  }
+  public String generateUUID() {
+    return UUID.randomUUID().toString();
+  }
+  private ReturnCode sendMail(String from, String replyto, String tolist, String cclist, String bcclist, String subject, String message, String messagemimetype, FileSetResource attachments, String mailhost, int mailport, String user, String password, String charset, boolean tls, boolean ssl)
+  {
+    EmailTask mail = new EmailTask();
+    mail.setTaskName("Mail");
+    RunTask runner = new RunTask(mail);
+    mail.setFrom(from);
+    mail.setReplyTo(replyto);
+    mail.setToList(tolist);
+    mail.setCcList(cclist);
+    mail.setBccList(bcclist);
+    mail.setSubject(subject);
+    mail.setMessage(message);
+    mail.setMessageMimeType(messagemimetype);
+    if (attachments != null) {
+      mail.addFileset(attachments.getAntResource(mail.getProject()));
+    }
+    mail.setMailhost(mailhost);
+    mail.setMailport(mailport);
+    mail.setUser(user);
+    mail.setPassword(password);
+    mail.setCharset(charset);
+    mail.setSSL(ssl);
+    mail.setEnableStartTLS(tls);
+    return runner.postTask();
+  }
+  private ReturnCode sleep(int hours, int minutes, int seconds, int milliseconds)
+  {
+    Sleep sleep = new Sleep();
+    sleep.setTaskName("Sleep");
+    RunTask runner = new RunTask(sleep);
+    sleep.setHours(hours);
+    sleep.setMinutes(minutes);
+    sleep.setSeconds(seconds);
+    sleep.setMilliseconds(milliseconds);
+    return runner.postTask();
+  }
+  public RuntimeInfoType getMemory() {
+    return new RuntimeInfoType();
+  }
+}

 /xservices/trunk/src/java/net/brutex/xservices/ws/impl/JobServiceImpl.java
 ,0 → 1,151
+/*
+ *   Copyright 2011 Brian Rosenberger (Brutex Network)
+ *
+ *   Licensed 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 net.brutex.xservices.ws.impl;
+import static org.quartz.TriggerBuilder.newTrigger;
+import java.util.ArrayList;
+import java.util.GregorianCalendar;
+import java.util.List;
+import java.util.Set;
+import java.util.TimeZone;
+import java.util.UUID;
+import javax.jws.WebService;
+import org.quartz.JobBuilder;
+import org.quartz.JobDataMap;
+import org.quartz.JobDetail;
+import org.quartz.JobKey;
+import org.quartz.Scheduler;
+import org.quartz.SchedulerException;
+import org.quartz.SimpleTrigger;
+import org.quartz.Trigger;
+import org.quartz.TriggerKey;
+import org.quartz.impl.StdSchedulerFactory;
+import org.quartz.impl.matchers.GroupMatcher;
+import net.brutex.xservices.types.ScheduledJob;
+import net.brutex.xservices.util.BrutexNamespaces;
+import net.brutex.xservices.util.JobWrapper;
+import net.brutex.xservices.ws.JobService;
+import net.brutex.xservices.ws.XServicesFault;
+/**
+ * @author Brian Rosenberger
+ * @since 0.5.0
+ *
+ */
+@WebService(targetNamespace = BrutexNamespaces.WS_XSERVICES, endpointInterface = "net.brutex.xservices.ws.JobService", serviceName = JobService.SERVICE_NAME)
+public class JobServiceImpl implements JobService {
+        public List<ScheduledJob> getJobList() throws XServicesFault {
+                List<ScheduledJob> joblist = new ArrayList<ScheduledJob>();
+                try {
+                        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
+                        List<String> jobgroups = scheduler.getJobGroupNames();
+                        for (String g : jobgroups) {
+                                GroupMatcher m = GroupMatcher.groupContains(g);
+                                Set<JobKey> keyset = scheduler.getJobKeys(m);
+                                for (JobKey key : keyset) {
+                                        JobDataMap detail = scheduler.getJobDetail(key)
+                                                        .getJobDataMap();
+                                        ScheduledJob job = new ScheduledJob(key.getName(),
+                                                        (GregorianCalendar) detail.get("date"),
+                                                        detail.getString("script"));
+                                        joblist.add(job);
+                                }
+                        }
+                } catch (SchedulerException e) {
+                        throw new XServicesFault(e);
+                }
+                return joblist;
+        }
+        public ScheduledJob getJob(String uuid) throws XServicesFault {
+                try {
+                        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
+                        JobDetail job = scheduler.getJobDetail(new JobKey(uuid, "DEFAULT"));
+                        if (job == null)
+                                throw new XServicesFault("Job not found.");
+                        Trigger t = scheduler.getTrigger(new TriggerKey(uuid));
+                        GregorianCalendar cal = new GregorianCalendar(TimeZone.getDefault());
+                        cal.setTime(t.getStartTime());
+                        return new ScheduledJob(uuid, cal, job.getJobDataMap().getString(
+                                        "script"), job.getDescription());
+                } catch (SchedulerException e) {
+                        e.printStackTrace();
+                        throw new XServicesFault(e);
+                }
+        }
+        public void deleteJob(String uuid) throws XServicesFault {
+                try {
+                        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
+                        JobKey key = new JobKey(uuid, "DEFAULT");
+                        JobDetail job = scheduler.getJobDetail(key);
+                        if (job == null)
+                                throw new XServicesFault("Job not found.");
+                        Trigger t = scheduler.getTrigger(new TriggerKey(uuid));
+                        scheduler.deleteJob(key);
+                } catch (SchedulerException e) {
+                        throw new XServicesFault(e);
+                }
+        }
+        public String scheduleJob(ScheduledJob job) throws XServicesFault {
+                try {
+                        // Grab the Scheduler instance from the Factory
+                        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
+                        // and start it off
+                        if (!scheduler.isStarted())
+                                scheduler.start();
+                        if (scheduler.isInStandbyMode())
+                                scheduler.resumeAll();
+                        String identity = UUID.randomUUID().toString();
+                        //String identity = "test";
+                        JobDetail job2 = JobBuilder.newJob(JobWrapper.class)
+                                        .withIdentity(identity).build();
+                        job2.getJobDataMap().put("script", job.getScript());
+                        job2.getJobDataMap().put("description", job.getDescription());
+                        job2.getJobDataMap().put("date", job.getDate());
+                        SimpleTrigger t = (SimpleTrigger) newTrigger()
+                                        .withIdentity(identity).startAt(job.getDate().getTime())
+                                        .build();
+                        ;
+                        scheduler.scheduleJob(job2, t);
+                        return identity;
+                } catch (SchedulerException e) {
+                        e.printStackTrace();
+                        throw new XServicesFault(e);
+                }
+        }
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /xservices/trunk/src/java/net/brutex/xservices/ws/impl/MailServiceImpl.java
 ,0 → 1,94
+/*
+ *   Copyright 2012 Brian Rosenberger (Brutex Network)
+ *
+ *   Licensed 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 net.brutex.xservices.ws.impl;
+import javax.jws.WebService;
+import net.brutex.xservices.types.HostConnection;
+import net.brutex.xservices.types.MailMimeType;
+import net.brutex.xservices.types.ReturnCode;
+import net.brutex.xservices.types.ant.FileSetResource;
+import net.brutex.xservices.util.BrutexNamespaces;
+import net.brutex.xservices.util.RunTask;
+import net.brutex.xservices.ws.MailService;
+import org.apache.tools.ant.taskdefs.email.EmailTask;
+/**
+ * Implements MailService
+ *
+ * @author Brian Rosenberger, bru@brutex.de
+ */
+@WebService(targetNamespace = BrutexNamespaces.WS_XSERVICES,
+                        endpointInterface = "net.brutex.xservices.ws.MailService",
+                        serviceName = "MailService")
+public class MailServiceImpl implements MailService {
+        public ReturnCode sendMailSimple(HostConnection mailhost, String from,
+                        String tolist, String subject, String message) {
+                return sendMail(from, from, tolist, "", "", subject, message,
+                                "text/plain", null, mailhost.hostname, mailhost.port,
+                                mailhost.user, mailhost.password, "utf-8", false, false);
+        }
+        public ReturnCode sendMailSimpleWithAttachment(HostConnection mailhost,
+                        String from, String tolist, String subject, String message,
+                        FileSetResource res) {
+                return sendMail(from, from, tolist, "", "", subject, message,
+                                "text/plain", res, mailhost.hostname, mailhost.port,
+                                mailhost.user, mailhost.password, "utf-8", false, false);
+        }
+        public ReturnCode sendMail(HostConnection mailhost, String from,
+                        String tolist, String cclist, String bcclist, String subject,
+                        MailMimeType mimetype, String charset, String message,
+                        FileSetResource res, boolean ssl, boolean tls) {
+                return sendMail(from, from, tolist, cclist, bcclist, subject, message,
+                                mimetype.value(), res, mailhost.hostname, mailhost.port,
+                                mailhost.user, mailhost.password, charset, tls, ssl);
+        }
+        private ReturnCode sendMail(String from, String replyto, String tolist,
+                        String cclist, String bcclist, String subject, String message,
+                        String messagemimetype, FileSetResource attachments,
+                        String mailhost, int mailport, String user, String password,
+                        String charset, boolean tls, boolean ssl) {
+                EmailTask mail = new EmailTask();
+                mail.setTaskName("Mail");
+                RunTask runner = new RunTask(mail);
+                mail.setFrom(from);
+                mail.setReplyTo(replyto);
+                mail.setToList(tolist);
+                mail.setCcList(cclist);
+                mail.setBccList(bcclist);
+                mail.setSubject(subject);
+                mail.setMessage(message);
+                mail.setMessageMimeType(messagemimetype);
+                if (attachments != null) {
+                        mail.addFileset(attachments.getAntResource(mail.getProject()));
+                }
+                mail.setMailhost(mailhost);
+                mail.setMailport(mailport);
+                mail.setUser(user);
+                mail.setPassword(password);
+                mail.setCharset(charset);
+                mail.setSSL(ssl);
+                mail.setEnableStartTLS(tls);
+                return runner.postTask();
+        }
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /xservices/trunk/src/java/net/brutex/xservices/ws/ArchiveService.java
 ,0 → 1,205
+/*
+g *   Copyright 2010 Brian Rosenberger (Brutex Network)
+ *
+ *   Licensed 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 net.brutex.xservices.ws;
+import javax.jws.WebMethod;
+import javax.jws.WebParam;
+import javax.jws.WebService;
+import net.brutex.xservices.types.CompressionType;
+import net.brutex.xservices.types.ReturnCode;
+import net.brutex.xservices.types.ant.ArchiveResource;
+import net.brutex.xservices.types.ant.FileResource;
+import net.brutex.xservices.types.ant.FileSetResource;
+import net.brutex.xservices.util.BrutexNamespaces;
+/**
+ * Archiving related web service.
+ *
+ * @author Brian Rosenberger, bru@brutex.de
+ * @since 0.4.0
+ */
+@WebService(targetNamespace = BrutexNamespaces.WS_XSERVICES)
+public interface ArchiveService {
+    final String WS_OPERATION_BZIP2 = "bzip2";
+    final String WS_OPERATION_BZIP2_ARCHIVE = "bzip2FromArchive";
+    final String WS_OPERATION_GZIP = "gzip";
+    final String WS_OPERATION_GZIP_ARCHIVE = "gzipFromArchive";
+    final String WS_OPERATION_UNZIP = "unzip";
+    final String WS_OPERATION_GUNZIP = "gunzip";
+    final String WS_OPERATION_BUNZIP2 = "bunzip2";
+    final String WS_PARAM_SOURCEFILE = "source";
+    final String WS_PARAM_SOURCEFILE_STRING = "srcfile";
+    final String WS_PARAM_SOURCEURL = "srcurl";
+    final String WS_PARAM_SOURCEARCHIVE = "archivesource";
+    final String WS_PARAM_DESTFILE = "destfile";
+    final String WS_PARAM_DESTDIR = "destdir";
+    final String WS_PARAM_ENCODING = "encoding";
+    final String WS_PARAM_OVERWRITE = "overwrite";
+    final String WS_PARAM_COMPRESS = "compresslevel";
+    /**
+     * @param src
+     * @param file
+     * @return
+     * @throws XServicesFault
+     */
+    @WebMethod(operationName = WS_OPERATION_BZIP2, action = WS_OPERATION_BZIP2)
+    public ReturnCode bzip2(@WebParam(name = WS_PARAM_SOURCEFILE) FileResource src,
+            @WebParam(name = WS_PARAM_DESTFILE) String file) throws XServicesFault;
+    /**
+     * @param src
+     * @param file
+     * @return
+     * @throws XServicesFault
+     */
+    @WebMethod(operationName = WS_OPERATION_BZIP2_ARCHIVE, action = WS_OPERATION_BZIP2_ARCHIVE)
+    public ReturnCode bzip2FromArchive(@WebParam(name = WS_PARAM_SOURCEARCHIVE) ArchiveResource src,
+            @WebParam(name = WS_PARAM_DESTFILE) String file) throws XServicesFault;
+    /**
+     * @param src
+     * @param file
+     * @return
+     * @throws XServicesFault
+     */
+    @WebMethod(operationName = WS_OPERATION_GZIP, action = WS_OPERATION_GZIP)
+    public ReturnCode gzip(@WebParam(name = WS_PARAM_SOURCEFILE) FileResource src,
+            @WebParam(name = WS_PARAM_DESTFILE) String file) throws XServicesFault;
+    /**
+     * @param src
+     * @param file
+     * @return
+     * @throws XServicesFault
+     */
+    @WebMethod(operationName = WS_OPERATION_GZIP_ARCHIVE, action = WS_OPERATION_GZIP_ARCHIVE)
+    public ReturnCode gzipFromArchive(@WebParam(name = WS_PARAM_SOURCEARCHIVE) ArchiveResource src,
+            @WebParam(name = WS_PARAM_DESTFILE) String file) throws XServicesFault;
+    /**
+     * @param src
+     * @param dest
+     * @return
+     * @throws XServicesFault
+     */
+    @WebMethod(operationName = WS_OPERATION_GUNZIP, action = WS_OPERATION_GUNZIP)
+    public ReturnCode gunzip(@WebParam(name = WS_PARAM_SOURCEFILE_STRING) String src,
+            @WebParam(name = WS_PARAM_DESTDIR) String dest) throws XServicesFault;
+    /**
+     * @param src
+     * @param dest
+     * @return
+     * @throws XServicesFault
+     */
+    @WebMethod(operationName = WS_OPERATION_BUNZIP2)
+    public ReturnCode bunzip2(@WebParam(name = WS_PARAM_SOURCEFILE_STRING) String src,
+            @WebParam(name = WS_PARAM_DESTDIR) String dest) throws XServicesFault;
+    /**
+     * @param src
+     * @param dest
+     * @return
+     * @throws XServicesFault
+     */
+    @WebMethod(operationName = "gunzipFromURL")
+    public ReturnCode gunzipFromURL(@WebParam(name = WS_PARAM_SOURCEURL) String src,
+            @WebParam(name = WS_PARAM_DESTDIR) String dest) throws XServicesFault;
+    /**
+     * @param src
+     * @param dest
+     * @return
+     * @throws XServicesFault
+     */
+    @WebMethod(operationName = "bunzip2FromURL")
+    public ReturnCode bunzip2FromURL(@WebParam(name = WS_PARAM_SOURCEURL) String src,
+            @WebParam(name = WS_PARAM_DESTDIR) String dest) throws XServicesFault;
+    /**
+     * @param src
+     * @param file
+     * @param overwrite
+     * @param encoding
+     * @param level
+     * @return
+     * @throws XServicesFault
+     */
+    @WebMethod(operationName = "zip")
+    public ReturnCode zip(@WebParam(name = WS_PARAM_SOURCEFILE) FileResource src,
+            @WebParam(name = WS_PARAM_DESTFILE) String file,
+            @WebParam(name = WS_PARAM_OVERWRITE) boolean overwrite,
+            @WebParam(name = WS_PARAM_ENCODING) String encoding,
+            @WebParam(name = WS_PARAM_COMPRESS) int level) throws XServicesFault;
+    /**
+     * @param src
+     * @param file
+     * @param update
+     * @param encoding
+     * @param level
+     * @return
+     * @throws XServicesFault
+     */
+    @WebMethod(operationName = "zipFromArchive")
+    public ReturnCode zipFromArchive(@WebParam(name = WS_PARAM_SOURCEARCHIVE) ArchiveResource src,
+            @WebParam(name = WS_PARAM_DESTFILE) String file,
+            @WebParam(name = WS_PARAM_OVERWRITE) boolean update,
+            @WebParam(name = WS_PARAM_ENCODING) String encoding,
+            @WebParam(name = "compresslevel") int level) throws XServicesFault;
+    /**
+     * @param src
+     * @param dest
+     * @param overwrite
+     * @param encoding
+     * @return
+     * @throws XServicesFault
+     */
+    @WebMethod(operationName = "unzip")
+    public ReturnCode unzip(@WebParam(name = WS_PARAM_SOURCEFILE_STRING) String src,
+            @WebParam(name = WS_PARAM_DESTDIR) String dest,
+            @WebParam(name = WS_PARAM_OVERWRITE) boolean overwrite,
+            @WebParam(name = WS_PARAM_ENCODING) String encoding) throws XServicesFault;
+    /**
+     * @param src
+     * @param dest
+     * @return
+     * @throws XServicesFault
+     */
+    @WebMethod(operationName = "unrar")
+    public ReturnCode unrar(@WebParam(name = WS_PARAM_SOURCEFILE_STRING) String src,
+            @WebParam(name = WS_PARAM_DESTDIR) String dest) throws XServicesFault;
+    /**
+     * @param src
+     * @param dest
+     * @param overwrite
+     * @param compression
+     * @return
+     * @throws XServicesFault
+     */
+    @WebMethod(operationName = "untar")
+    public ReturnCode untar(@WebParam(name = WS_PARAM_SOURCEFILE_STRING) String src,
+            @WebParam(name = WS_PARAM_DESTDIR) String dest,
+            @WebParam(name = WS_PARAM_OVERWRITE) boolean overwrite,
+            @WebParam(name = "compression") CompressionType compression) throws XServicesFault;
+}

 /xservices/trunk/src/java/net/brutex/xservices/ws/rs/FileInfo.java
 ,0 → 1,82
+/*
+ *   Copyright 2013 Brian Rosenberger (Brutex Network)
+ *
+ *   Licensed 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 net.brutex.xservices.ws.rs;
+import java.io.File;
+import javax.ws.rs.DefaultValue;
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.Produces;
+import javax.ws.rs.QueryParam;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.HttpHeaders;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.UriInfo;
+import net.brutex.xservices.ws.XServicesFault;
+/**
+ * The FileBrowsing Rest Service.
+ *
+ * @author Brian Rosenberger, bru(at)brutex.de
+ */
+@Path("/FileService/")
+@Produces({ "text/xml" })
+public abstract interface FileInfo {
+        public final static String BASE_PATH = "/FileService/";
+        public final static String SERVICE_NAME = "FileInfoService";
+        /**
+         * Get the file/ directory listing.
+         *
+         * @param paramHttpHeaders the param http headers
+         * @param uriInfo request url info
+         * @param directory The directory to list.
+         * @param includeDirectories Whether or not to include directories in the listing. Default is true.
+         * @param includeFiles Whether or not to include files in the listing. Default is true.
+         * @param depth Include subdirectories down to a given depth. Default is 1.
+         * @param search Additional "Glob search pattern" for the file/ directory name. I.e. '*.log'
+         * @param itemsPerPage How many items to return with one call. Default is 50.
+         * @param page Paging support. Default is 1.
+         * @param useCache whether or not to use cache. Defaults to true.
+         * @return the FileInfo Set as an XML structure
+         */
+        @GET
+        @Path("getFiles/")
+        public abstract Response getFiles(
+                        @Context HttpHeaders paramHttpHeaders,
+                        @Context UriInfo uriInfo,
+                        @QueryParam("directory") String directory,
+                        @QueryParam("includeDirectories") @DefaultValue("0") boolean includeDirectories,
+                        @QueryParam("includeFiles") @DefaultValue("1") boolean includeFiles,
+                        @QueryParam("depth") @DefaultValue("1") int depth,
+                        @QueryParam("search") String search,
+                        @QueryParam("itemsPerPage") @DefaultValue("50") int itemsPerPage,
+                        @QueryParam("page") @DefaultValue("1") int page,
+                        @QueryParam("usecache") @DefaultValue("1") boolean useCache);
+        @GET
+        @Path("getFile/")
+        //@Produces("application/octet-stream")
+        public abstract Response getFile(
+                        @Context HttpHeaders paramHttpHeaders,
+                        @QueryParam("file") String file);
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /xservices/trunk/src/java/net/brutex/xservices/ws/rs/FileInfoImpl.java
 ,0 → 1,268
+/*
+ *   Copyright 2013 Brian Rosenberger (Brutex Network)
+ *
+ *   Licensed 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 net.brutex.xservices.ws.rs;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.net.URI;
+import java.nio.file.DirectoryStream;
+import java.nio.file.FileSystems;
+import java.nio.file.FileVisitOption;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.PathMatcher;
+import java.nio.file.SimpleFileVisitor;
+import java.nio.file.attribute.BasicFileAttributeView;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+import javax.ws.rs.NotAuthorizedException;
+import javax.ws.rs.WebApplicationException;
+import javax.ws.rs.core.GenericEntity;
+import javax.ws.rs.core.HttpHeaders;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.StreamingOutput;
+import javax.ws.rs.core.UriInfo;
+import net.brutex.xservices.security.DirectoryPermission;
+import net.brutex.xservices.types.FileInfoType;
+import net.brutex.xservices.util.FileWalker;
+import org.apache.jcs.JCS;
+import org.apache.jcs.access.exception.CacheException;
+import org.apache.log4j.Logger;
+import org.apache.shiro.SecurityUtils;
+import org.apache.shiro.authz.UnauthorizedException;
+/**
+ * The Class FileInfoImpl.
+ *
+ * @author Brian Rosenberger, bru(at)brutex.de
+ */
+public class FileInfoImpl  implements FileInfo {
+        Logger logger = Logger.getLogger(FileInfoImpl.class);
+  /* (non-Javadoc)
+   * @see net.brutex.xservices.ws.rs.FileInfo#getFiles(javax.ws.rs.core.HttpHeaders, java.lang.String, boolean, boolean, int, java.lang.String, int, int)
+   */
+  public Response getFiles(HttpHeaders h, UriInfo uriInfo, String dir, boolean withDir, boolean withFiles, int level, String search, int count, int page, boolean useCache)
+  {
+        if(dir==null) {
+                dir = "c:/";
+                logger.warn("No directory specified. Default is 'c:/'.");
+                }
+        isPermitted(dir);
+    URI baseuri = URI.create(uriInfo.getBaseUri()+FileInfo.BASE_PATH+"getFile?file=");
+    logger.info(String.format("Listing directory '%s'.", dir));
+    if (level <= 0) level = 1;
+    if ((!withDir) && (!withFiles)) withFiles = true;
+    String cachekey = level + "||" + withFiles + "||" + withDir + "||" + search + "||" + dir;
+    try {
+      logger.debug(String.format("Hitting cache with cachekey '%s'", cachekey));
+      JCS jcs = JCS.getInstance("FileCache");
+      /*Try to retrieve the file list from the cache*/
+      List<FileInfoType> list = (List<FileInfoType>)jcs.get(cachekey);
+      if (list == null || !useCache) {
+        list = setDirectory(baseuri, dir, withDir, withFiles, level, search);
+        jcs.put(cachekey, list);
+        logger.debug("Stored in Cache: " + list.toString());
+      } else {
+        logger.debug("Got from Cache: " + list.toString());
+      }
+      int fromIndex = 0;
+      int toIndex = 0;
+      fromIndex = (page - 1) * count;
+      toIndex = page * count;
+      if (toIndex > list.size()) toIndex = list.size();
+      if (fromIndex > toIndex) fromIndex = toIndex;
+      GenericEntity<List<FileInfoType>> sublist = new GenericEntity<List<FileInfoType>>(list.subList(fromIndex, toIndex)) {};
+      logger.info(String.format("Returning items %s to %s from total of %s items in the list.", fromIndex, toIndex, list.size()));
+      return Response.ok(sublist).build();
+    } catch (CacheException e) {
+      return Response.serverError().build();
+    }
+  }
+  /**
+   * Sets the directory.
+   *
+   * @param list the list
+   * @param dir the dir
+   * @param withDirectories the with directories
+   * @param withFiles the with files
+   * @param depth the depth
+   * @param search the search
+   */
+  private void setDirectory(final URI baseuri, final List<FileInfoType> list, File dir, boolean withDirectories, boolean withFiles, final int depth, String search)
+  {
+    if (depth <= 0) return;
+        if(search==null || search.equals("") ) {
+                search = "*";
+                logger.info("No search pattern supplied, using default '*'.");
+        }
+        FileWalker finder = new FileWalker(search);
+        try {
+                        Files.walkFileTree(dir.toPath(), EnumSet.of(FileVisitOption.FOLLOW_LINKS), depth, finder);
+                        logger.info("FileWalker returned '"+finder.getCount()+"' hits. '" + finder.getTotal() + "' files have been scanned.");
+                        List<Path> result = finder.getResult();
+                for(Path f : result) {
+                        if(! withDirectories) {
+                                if(f.toFile().isDirectory()) continue;
+                        }
+                        if(! withFiles) {
+                                if(f.toFile().isFile()) continue;
+                        }
+                        list.add(new FileInfoType(f, baseuri));
+                }
+                } catch (IOException e2) {
+                        logger.error(e2.getMessage(), e2);;
+                }
+  }
+  /**
+   * Sets the directory.
+   *
+   * @param dir the dir
+   * @param withDirectories the with directories
+   * @param withFiles the with files
+   * @param depth the depth
+   * @param search the search
+   * @return the list
+   */
+  private List<FileInfoType> setDirectory(URI baseuri, String dir, boolean withDirectories, boolean withFiles, int depth, String search)
+  {
+    List<FileInfoType> list = new ArrayList<FileInfoType>();
+    setDirectory(baseuri, list, new File(dir), withDirectories, withFiles, depth, search);
+    return list;
+  }
+@Override
+public Response getFile(HttpHeaders paramHttpHeaders, String file) {
+        isPermitted(file);
+        try {
+        Path path = FileSystems.getDefault().getPath(file);
+        BasicFileAttributeView basicView = Files.getFileAttributeView(path, BasicFileAttributeView.class);
+        BasicFileAttributes basic;
+        basic = basicView.readAttributes();
+        //In case this is a directory
+        //we zip it and return the zip stream
+        if(basic.isDirectory()) return getDirectoryAsZip(path);
+        MediaType mime = MediaType.APPLICATION_OCTET_STREAM_TYPE;
+        try {
+                mime = MediaType.valueOf(Files.probeContentType(path));
+        } catch (IllegalArgumentException | IOException e) {
+                //In case we can not find the media type for some reason
+                //the default assignment is taken, so we can
+                //ignore this error.
+                logger.debug(String.format("Could not probe media type for file '%s'. Default is '%s'", path.toString(), mime.getType()), e);
+        }
+        Response r = Response.ok(path.toFile(), mime).build();
+        String fileName = path.getFileName().toString();
+        if(mime == MediaType.APPLICATION_OCTET_STREAM_TYPE) r.getHeaders().add("Content-Disposition", "attachment; filename=\"" + fileName + "\"");
+        return r;
+                } catch (IOException e1) {
+                        // TODO Auto-generated catch block
+                        logger.error(e1.getMessage(), e1);
+                        return Response.serverError().build();
+                }
+}
+private Response getDirectoryAsZip(final Path path) {
+        StreamingOutput output = new StreamingOutput() {
+                @Override
+                public void write(OutputStream os) throws IOException,
+                                WebApplicationException {
+                        ZipOutputStream zos = new ZipOutputStream(os);
+                        //read directory content (files only)
+                        try (DirectoryStream<Path> stream = Files.newDirectoryStream(path)) {
+                            for (Path file: stream) {
+                                //skip anything not being a file
+                                if(! file.toFile().isFile()) continue;
+                                //ZipEntry
+                                String filename = file.getFileName().toString();
+                                ZipEntry ze = new ZipEntry(filename);
+                                zos.putNextEntry( ze );
+                                //read a file and put it into the output stream
+                                FileInputStream fis = new FileInputStream(file.toFile());
+                                byte[] buffer = new byte[1024];
+                                int len;
+                                while ((len = fis.read(buffer)) > 0) {
+                                        zos.write(buffer, 0, len);
+                                }
+                                zos.flush();
+                                fis.close();
+                            }
+                            zos.close();
+                        }
+                }
+        };
+        Response r = Response.ok(output, MediaType.APPLICATION_OCTET_STREAM_TYPE).build();
+        String zipname = (path.getFileName()==null) ? "null.zip" : path.getFileName().toString()+".zip";
+        r.getHeaders().add("Content-Disposition", "attachment; filename=\"" + zipname + "\"");
+        return r;
+}
+private boolean isPermitted(String dir) {
+        if(! SecurityUtils.getSubject().isPermitted( new DirectoryPermission(dir))) {
+                logger.warn(String.format("User '%s' does not have permission to access '%s'.",SecurityUtils.getSubject().getPrincipal(), dir ));
+                throw new NotAuthorizedException(new UnauthorizedException("User does not have permission to access "+ dir));
+        }
+        return true;
+}
+//http://stackoverflow.com/questions/3758606/how-to-convert-byte-size-into-human-readable-format-in-java
+private static String humanReadableByteCount(long bytes, boolean si) {
+    int unit = si ? 1000 : 1024;
+    if (bytes < unit) return bytes + " B";
+    int exp = (int) (Math.log(bytes) / Math.log(unit));
+    String pre = (si ? "kMGTPE" : "KMGTPE").charAt(exp-1) + (si ? "" : "i");
+    return String.format("%.1f %sB", bytes / Math.pow(unit, exp), pre);
+}
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /xservices/trunk/src/java/net/brutex/xservices/ws/rs/FileListType.java
 ,0 → 1,37
+/*
+ *   Copyright 2014 Brian Rosenberger (Brutex Network)
+ *
+ *   Licensed 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 net.brutex.xservices.ws.rs;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlRootElement;
+@XmlRootElement(name="FileList")
+public class FileListType
+{
+  @XmlElement
+  public String name;
+  public FileListType()
+  {
+  }
+  public FileListType(String name)
+  {
+    this.name = name;
+  }
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /xservices/trunk/src/java/net/brutex/xservices/ws/rs/ResultType.java
 ,0 → 1,34
+/*
+ *   Copyright 2014 Brian Rosenberger (Brutex Network)
+ *
+ *   Licensed 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 net.brutex.xservices.ws.rs;
+import net.brutex.xservices.types.scm.ItemType;
+class ResultType
+{
+  private ItemType result = null;
+  ItemType getResult()
+  {
+    return this.result;
+  }
+  void setResult(ItemType result)
+  {
+    this.result = result;
+  }
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /xservices/trunk/src/java/net/brutex/xservices/ws/rs/DIMCMInfo.java
 ,0 → 1,80
+/*
+ *   Copyright 2014 Brian Rosenberger (Brutex Network)
+ *
+ *   Licensed 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 net.brutex.xservices.ws.rs;
+import java.io.File;
+import javax.ws.rs.DefaultValue;
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.Produces;
+import javax.ws.rs.QueryParam;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.HttpHeaders;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.UriInfo;
+import org.apache.jcs.access.exception.CacheException;
+import net.brutex.xservices.ws.XServicesFault;
+/**
+ * The Dim CM Browsing Rest Service.
+ *
+ * @author Brian Rosenberger, bru(at)brutex.de
+ */
+@Path("/")
+@Produces({ "text/xml" })
+public abstract interface DIMCMInfo {
+        public final static String BASE_PATH = "/DIMCMService/";
+        public final static String SERVICE_NAME = "DIMCMInfoService";
+        /**
+         * Get the file/ directory listing.
+         *
+         * @param paramHttpHeaders the param http headers
+         * @param uriInfo request url info
+         * @param directory The directory to list.
+         * @param includeDirectories Whether or not to include directories in the listing. Default is true.
+         * @param includeFiles Whether or not to include files in the listing. Default is true.
+         * @param depth Include subdirectories down to a given depth. Default is 1.
+         * @param search Additional "Glob search pattern" for the file/ directory name. I.e. '*.log'
+         * @param itemsPerPage How many items to return with one call. Default is 50.
+         * @param page Paging support. Default is 1.
+         * @param useCache whether or not to use cache. Defaults to true.
+         * @return the FileInfo Set as an XML structure
+         * @throws CacheException
+         */
+        @GET
+        @Path("getItems/")
+        public abstract Response getFiles(
+                        @Context HttpHeaders paramHttpHeaders,
+                        @Context UriInfo uriInfo,
+                        @QueryParam("projSpec") String project,
+                        @QueryParam("directory") String directory,
+                        @QueryParam("recursive") @DefaultValue("false") boolean recursive,
+                        @QueryParam("includeFiles") @DefaultValue("1") boolean includeFiles,
+                        @QueryParam("depth") @DefaultValue("1") int depth,
+                        @QueryParam("search") String search,
+                        @QueryParam("itemsPerPage") @DefaultValue("50") int itemsPerPage,
+                        @QueryParam("page") @DefaultValue("1") int page,
+                        @QueryParam("usecache") @DefaultValue("true") boolean useCache) throws CacheException;
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /xservices/trunk/src/java/net/brutex/xservices/ws/rs/DIMCMInfoImpl.java
 ,0 → 1,371
+/*
+ *   Copyright 2014 Brian Rosenberger (Brutex Network)
+ *
+ *   Licensed 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 net.brutex.xservices.ws.rs;
+import java.io.File;
+import java.io.IOException;
+import java.net.MalformedURLException;
+import java.net.URI;
+import java.net.URL;
+import java.nio.file.FileVisitOption;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.List;
+import javax.ws.rs.core.HttpHeaders;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.UriInfo;
+import net.brutex.xservices.cmtypes.ItemType;
+import net.brutex.xservices.cmtypes.ItemTypeList;
+import net.brutex.xservices.types.FileInfoType;
+import net.brutex.xservices.util.FileWalker;
+import org.apache.commons.configuration.ConfigurationException;
+import org.apache.commons.configuration.PropertiesConfiguration;
+import org.apache.jcs.JCS;
+import org.apache.jcs.access.exception.CacheException;
+import org.apache.log4j.Logger;
+/*
+ * The Serena Dimensions CM Java API is required for these imports.
+ * The API is not included in this package due to copyright reasons,
+ * please get Dimensions CM from Serena Software Inc., Evaluation versions
+ * are available from http://www.serena.com
+ *
+ * required Jars:
+ * serena.darius-14.1.jar
+ * serena.dmclient-14.1.jar
+ * serena.dmfile-14.1.jar
+ * serena.dmnet-14.1.jar
+ * serena.dmtpi-14.1.jar
+ *
+ */
+import com.serena.dmclient.api.BulkOperator;
+import com.serena.dmclient.api.DimensionsConnection;
+import com.serena.dmclient.api.DimensionsConnectionDetails;
+import com.serena.dmclient.api.DimensionsConnectionManager;
+import com.serena.dmclient.api.ItemRevision;
+import com.serena.dmclient.api.Project;
+import com.serena.dmclient.api.RepositoryFolder;
+import com.serena.dmclient.api.SystemAttributes;
+/**
+ * The Class FileInfoImpl.
+ *
+ * @author Brian Rosenberger, bru(at)brutex.de
+ */
+public class DIMCMInfoImpl implements DIMCMInfo {
+        Logger logger = Logger.getLogger(DIMCMInfoImpl.class);
+        /*
+         * (non-Javadoc)
+         *
+         * @see
+         * net.brutex.xservices.ws.rs.FileInfo#getFiles(javax.ws.rs.core.HttpHeaders
+         * , java.lang.String, boolean, boolean, int, java.lang.String, int, int)
+         */
+        public Response getFiles(HttpHeaders h, UriInfo uriInfo, String projSpec,
+                        String directory, boolean recursive, boolean withFiles, int level,
+                        String search, int count, int page, boolean useCache) throws CacheException {
+                /*
+                 * try to hit cache first
+                 */
+                JCS cache = JCS.getInstance("DIMCM");
+                String cachekey = projSpec + directory + String.valueOf(recursive);
+                if(useCache) {
+                                ItemTypeList cacheresult = (ItemTypeList) cache.get(cachekey);
+                                if(cacheresult != null) return Response.ok(cacheresult).build();
+                }
+                //Reject when project has not the form "PRODUCT:PROJECT"
+                if(! projSpec.contains(":")) return Response.noContent().build();
+                Project project = getDIMCMConnection().getObjectFactory().getProject(projSpec);
+                RepositoryFolder folder = null;
+                if (directory == null) {
+                        folder = project.getRootFolder();
+                } else {
+                        while(directory.startsWith("/") || directory.startsWith("\\")) {
+                                directory = directory.substring(1);
+                        }
+                        if(directory.equals("")) {
+                                folder = project.getRootFolder();
+                        } else {
+                                folder = project.findRepositoryFolderByPath(directory);
+                        }
+                }
+                ItemTypeList resultlist = new ItemTypeList();
+                resultlist.list = getItems(folder, recursive);
+                if(cache!=null) cache.put(cachekey, resultlist);
+                //does this help?
+                DimensionsConnectionManager.unregisterThreadConnection();
+                return Response.ok(resultlist).build();
+        }
+        List<ItemType> getItems(RepositoryFolder f, boolean recursive) {
+                DimensionsConnection conn = getDIMCMConnection();
+                List<ItemType> result = new ArrayList<>();
+                /* get Items from current folder */
+                /* latest revision only */
+                List<ItemRevision> revisions = f.getLatestItemRevisions();
+                int[] attr = { SystemAttributes.FULL_PATH_NAME,
+                                SystemAttributes.ITEMFILE_DIR,
+                                SystemAttributes.ITEMFILE_FILENAME,
+                                SystemAttributes.ITEMFILE_DIR, SystemAttributes.OBJECT_SPEC,
+                                SystemAttributes.OBJECT_ID, SystemAttributes.OBJECT_SPEC_UID,
+                                SystemAttributes.OBJECT_UID, SystemAttributes.CREATION_DATE,
+                                SystemAttributes.CREATION_USER, SystemAttributes.ITEM_FORMAT,
+                                SystemAttributes.LAST_UPDATED_DATE,
+                                SystemAttributes.LAST_UPDATED_USER };
+                BulkOperator bulk = conn.getObjectFactory().getBulkOperator(revisions);
+                bulk.queryAttribute(attr);
+                // Copy into JAXB object
+                for (ItemRevision r : revisions) {
+                        ItemType item = new ItemType();
+                        item.setLongFilename((String) r
+                                        .getAttribute(SystemAttributes.FULL_PATH_NAME));
+                        item.setDirName((String) r
+                                        .getAttribute(SystemAttributes.ITEMFILE_DIR));
+                        item.setShortFilename((String) r
+                                        .getAttribute(SystemAttributes.ITEMFILE_FILENAME));
+                        item.setObject_id((String) r
+                                        .getAttribute(SystemAttributes.OBJECT_ID));
+                        item.setObject_uid((String.valueOf(r
+                                        .getAttribute(SystemAttributes.OBJECT_UID))));
+                        item.setObject_spec((String) r
+                                        .getAttribute(SystemAttributes.OBJECT_SPEC));
+                        item.setObject_spec_uid(String.valueOf(r
+                                        .getAttribute(SystemAttributes.OBJECT_SPEC_UID)));
+                        item.setObject_spec_uid(String.valueOf(r
+                                        .getAttribute(SystemAttributes.OBJECT_SPEC_UID)));
+                        item.setCreatedDate(String.valueOf(r
+                                        .getAttribute(SystemAttributes.CREATION_DATE)));
+                        item.setCreatedUser(String.valueOf(r
+                                        .getAttribute(SystemAttributes.CREATION_USER)));
+                        item.setItemFormat(String.valueOf(r
+                                        .getAttribute(SystemAttributes.ITEM_FORMAT)));
+                        item.setUpdatedDate(String.valueOf(r
+                                        .getAttribute(SystemAttributes.LAST_UPDATED_DATE)));
+                        item.setUpdatedUser(String.valueOf(r
+                                        .getAttribute(SystemAttributes.LAST_UPDATED_USER)));
+                        try {
+                                item.setUrl(new URL(getBaseURL()
+                                                + "?jsp=api&command=openi&object_id="
+                                                + item.getObject_spec() + "&DB_CONN="
+                                                + conn.getConnectionDetails().getDbConn() + "&DB_NAME="
+                                                + conn.getConnectionDetails().getDbName()));
+                        } catch (MalformedURLException e) {
+                                // TODO Auto-generated catch block
+                                e.printStackTrace();
+                        }
+                        result.add(item);
+                }
+                /*
+                 * for recursive add other folders
+                 */
+                if(recursive) {
+                        List<RepositoryFolder> folders = f.getAllChildFolders();
+                        for(RepositoryFolder ff : folders) {
+                                result.addAll(getItems(ff, false));
+                        }
+                }
+                return result;
+        }
+        /**
+         * Sets the directory.
+         *
+         * @param list
+         *            the list
+         * @param dir
+         *            the dir
+         * @param withDirectories
+         *            the with directories
+         * @param withFiles
+         *            the with files
+         * @param depth
+         *            the depth
+         * @param search
+         *            the search
+         */
+        private void setDirectory(final URI baseuri, final List<FileInfoType> list,
+                        File dir, boolean withDirectories, boolean withFiles,
+                        final int depth, String search) {
+                if (depth <= 0)
+                        return;
+                if (search == null || search.equals("")) {
+                        search = "*";
+                        logger.info("No search pattern supplied, using default '*'.");
+                }
+                FileWalker finder = new FileWalker(search);
+                try {
+                        Files.walkFileTree(dir.toPath(),
+                                        EnumSet.of(FileVisitOption.FOLLOW_LINKS), depth, finder);
+                        logger.info("FileWalker returned '" + finder.getCount()
+                                        + "' hits. '" + finder.getTotal()
+                                        + "' files have been scanned.");
+                        List<Path> result = finder.getResult();
+                        for (Path f : result) {
+                                if (!withDirectories) {
+                                        if (f.toFile().isDirectory())
+                                                continue;
+                                }
+                                if (!withFiles) {
+                                        if (f.toFile().isFile())
+                                                continue;
+                                }
+                                list.add(new FileInfoType(f, baseuri));
+                        }
+                } catch (IOException e2) {
+                        logger.error(e2.getMessage(), e2);
+                        ;
+                }
+        }
+        /**
+         * Sets the directory.
+         *
+         * @param dir
+         *            the dir
+         * @param withDirectories
+         *            the with directories
+         * @param withFiles
+         *            the with files
+         * @param depth
+         *            the depth
+         * @param search
+         *            the search
+         * @return the list
+         */
+        private List<FileInfoType> setDirectory(URI baseuri, String dir,
+                        boolean withDirectories, boolean withFiles, int depth, String search) {
+                List<FileInfoType> list = new ArrayList<FileInfoType>();
+                setDirectory(baseuri, list, new File(dir), withDirectories, withFiles,
+                                depth, search);
+                return list;
+        }
+        private boolean isPermitted(String dir) {
+                /*
+                 *
+                 * logger.warn(String.format(
+                 * "User '%s' does not have permission to access '%s'."
+                 * ,SecurityUtils.getSubject().getPrincipal(), dir )); throw new
+                 * NotAuthorizedException(new
+                 * UnauthorizedException("User does not have permission to access "+
+                 * dir)); }
+                 */
+                return true;
+        }
+        // http://stackoverflow.com/questions/3758606/how-to-convert-byte-size-into-human-readable-format-in-java
+        private static String humanReadableByteCount(long bytes, boolean si) {
+                int unit = si ? 1000 : 1024;
+                if (bytes < unit)
+                        return bytes + " B";
+                int exp = (int) (Math.log(bytes) / Math.log(unit));
+                String pre = (si ? "kMGTPE" : "KMGTPE").charAt(exp - 1)
+                                + (si ? "" : "i");
+                return String.format("%.1f %sB", bytes / Math.pow(unit, exp), pre);
+        }
+        private DimensionsConnection getDIMCMConnection() {
+                /*
+                 * Do we have a registered connection already?
+                 */
+                DimensionsConnection conn = null;
+                try {
+                        conn = DimensionsConnectionManager.getThreadConnection();
+                        if (conn != null)
+                                return conn;
+                } catch (Exception e) {
+                        logger.error(e.getMessage());
+                }
+                /*
+                 * Create a new connection from property file
+                 */
+                PropertiesConfiguration props;
+                try {
+                        props = new PropertiesConfiguration(this.getClass()
+                                        .getClassLoader().getResource("/../dimcm.properties"));
+                } catch (ConfigurationException e) {
+                        e.printStackTrace();
+                        return null;
+                }
+                DimensionsConnectionDetails details = new DimensionsConnectionDetails();
+                details.setUsername(props.getString("user"));
+                details.setPassword(props.getString("password"));
+                details.setDbName(props.getString("dbname"));
+                details.setDbConn(props.getString("dbconn"));
+                details.setServer(props.getString("server"));
+                conn = DimensionsConnectionManager.getConnection(details);
+                DimensionsConnectionManager.registerThreadConnection(conn);
+                return conn;
+        }
+        private String getBaseURL() {
+                final String CACHE_BASEURL = "DIMCM.conf.baseurl";
+        try {
+                JCS cache = JCS.getInstance("DIMCM");
+                String baseurl = (String) cache.get(CACHE_BASEURL);
+                if(baseurl != null) return baseurl;
+                PropertiesConfiguration props = new PropertiesConfiguration(this.getClass().getClassLoader().getResource("/../dimcm.properties"));
+                baseurl = props.getString("baseurl");
+                cache.put(CACHE_BASEURL, baseurl);
+                return baseurl;
+        } catch (CacheException e1) {
+                // TODO Auto-generated catch block
+                e1.printStackTrace();
+                return null;
+        } catch (ConfigurationException e) {
+                e.printStackTrace();
+                return null;
+        }
+}
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /xservices/trunk/src/java/net/brutex/xservices/ws/rs/CVSInfo.java
 ,0 → 1,47
+package net.brutex.xservices.ws.rs;
+import java.io.File;
+import javax.ws.rs.DefaultValue;
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.Produces;
+import javax.ws.rs.QueryParam;
+import javax.ws.rs.core.Context;
+import javax.ws.rs.core.HttpHeaders;
+import javax.ws.rs.core.Response;
+@Path("/CVSService/")
+@Produces({"application/xml", "application/json"})
+public abstract interface CVSInfo
+{
+  public static final String WS_OPERATION_GETREPOSITORYFILES = "getRepositoryFiles";
+  public static final String WS_OPERATION_GETMODULES = "getModules";
+  public static final String WS_OPERATION_GETTAGS = "getTags";
+  public static final String WS_OPERATION_GETFILECONTENT = "getFileContent";
+  public static final String WS_OPERATION_SEARCHFILECONTENT = "searchFileContent";
+  @GET
+  @Path("getRepositoryFiles")
+  public abstract Response getRepositoryFiles(@Context HttpHeaders paramHttpHeaders, @QueryParam("config") File paramFile, @QueryParam("modules") @DefaultValue("") String paramString, @QueryParam("recursive") @DefaultValue("false") boolean paramBoolean1, @QueryParam("showRevisions") @DefaultValue("false") boolean paramBoolean2, @QueryParam("forceNoCache") @DefaultValue("false") boolean paramBoolean3);
+  @GET
+  @Path("getModules")
+  public abstract Response getModules(@Context HttpHeaders paramHttpHeaders, @QueryParam("config") File paramFile, @QueryParam("forceNoCache") @DefaultValue("false") boolean paramBoolean);
+  @GET
+  @Path("getTags")
+  public abstract Response getTags(@Context HttpHeaders paramHttpHeaders, @QueryParam("config") File paramFile, @QueryParam("withFiles") @DefaultValue("false") boolean paramBoolean);
+  @GET
+  @Path("getFileContent")
+  public abstract Response getFileContent(@Context HttpHeaders paramHttpHeaders, @QueryParam("config") File paramFile, @QueryParam("file") String paramString, @QueryParam("forceNoCache") @DefaultValue("false") boolean paramBoolean);
+  @GET
+  @Path("searchFileContent")
+  public abstract Response searchFileContent(@Context HttpHeaders paramHttpHeaders, @QueryParam("config") File paramFile, @QueryParam("file_regexp") String paramString1, @QueryParam("content_regexp") String paramString2, @QueryParam("forceNoCache") @DefaultValue("false") boolean paramBoolean);
+}
+/* Location:           C:\Users\brosenberger\Documents\My Box Files\XBridgeNG-download\XServices-20130131 - Kopie\WEB-INF\classes\net.zip
+ * Qualified Name:     net.brutex.xservices.ws.rs.CVSInfo
+ * JD-Core Version:    0.6.2
+ */
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /xservices/trunk/src/java/net/brutex/xservices/ws/rs/CVSInfoImpl.java
 ,0 → 1,377
+package net.brutex.xservices.ws.rs;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.PrintStream;
+import java.net.URI;
+import java.util.List;
+import java.util.StringTokenizer;
+import javax.ws.rs.core.HttpHeaders;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.Response.ResponseBuilder;
+import net.brutex.xservices.types.scm.AttributeType;
+import net.brutex.xservices.types.scm.ItemListType;
+import net.brutex.xservices.types.scm.ItemType;
+import net.brutex.xservices.types.scm.ModuleListType;
+import net.brutex.xservices.types.scm.ModuleType;
+import net.brutex.xservices.types.scm.ObjectFactory;
+import net.brutex.xservices.types.scm.RevisionType;
+import net.brutex.xservices.types.scm.TagListType;
+import net.brutex.xservices.types.scmfindings.FindingsListType;
+import net.brutex.xservices.util.BasicCVSListener;
+import net.brutex.xservices.util.CVSClient;
+import net.brutex.xservices.util.CVSRoot;
+import org.apache.commons.configuration.ConfigurationException;
+import org.apache.jcs.JCS;
+import org.apache.jcs.access.exception.CacheException;
+import org.apache.log4j.Logger;
+import org.netbeans.lib.cvsclient.Client;
+import org.netbeans.lib.cvsclient.command.CommandAbortedException;
+import org.netbeans.lib.cvsclient.command.CommandException;
+import org.netbeans.lib.cvsclient.command.FileInfoContainer;
+import org.netbeans.lib.cvsclient.command.PipedFileInformation;
+import org.netbeans.lib.cvsclient.command.checkout.CheckoutCommand;
+import org.netbeans.lib.cvsclient.command.checkout.ModuleListInformation;
+import org.netbeans.lib.cvsclient.command.log.LogInformation;
+import org.netbeans.lib.cvsclient.command.log.LogInformation.Revision;
+import org.netbeans.lib.cvsclient.command.log.RlogCommand;
+import org.netbeans.lib.cvsclient.connection.AuthenticationException;
+import org.netbeans.lib.cvsclient.event.EventManager;
+import org.netbeans.lib.cvsclient.event.FileInfoEvent;
+public class CVSInfoImpl implements CVSInfo {
+        final Logger logger = Logger.getLogger(CVSInfoImpl.class);
+        final ObjectFactory FACTORY = new ObjectFactory();
+        final ItemListType list = this.FACTORY.createItemListType();
+        public Response getRepositoryFiles(HttpHeaders h, File f, String modules,
+                        boolean isRecursive, boolean showRevisions, boolean forceNoCache) {
+                String cachekey = "getFiles" + f.toURI().toString();
+                this.logger.debug("forceNoCache=" + forceNoCache);
+                ItemListType cacheresult = (ItemListType) getCacheInstance().get(
+                                cachekey);
+                if ((!forceNoCache) && (cacheresult != null)) {
+                        return Response.ok(cacheresult).build();
+                }
+                Client client;
+                try {
+                        final CVSClient cvsclient = new CVSClient(f);
+                        client = cvsclient.client;
+                        client.getEventManager().addCVSListener(new BasicCVSListener() {
+                                public void fileInfoGenerated(FileInfoEvent arg0) {
+                                        LogInformation info = (LogInformation) arg0
+                                                        .getInfoContainer();
+                                        String repoPath = cvsclient.client.getRepository();
+                                        ItemType cvsfile = CVSInfoImpl.this.FACTORY
+                                                        .createItemType();
+                                        cvsfile.setIsLeaf(true);
+                                        cvsfile.setIsBinary(false);
+                                        cvsfile.setFullname(info.getRepositoryFilename().substring(
+                                                        repoPath.length() + 2,
+                                                        info.getRepositoryFilename().length() - 2));
+                                        cvsfile.setRemotename(info.getRepositoryFilename());
+                                        cvsfile.setRemotefullname(info.getRepositoryFilename());
+                                        RevisionType revision = CVSInfoImpl.this.FACTORY
+                                                        .createRevisionType();
+                                        revision.setRevision(info.getHeadRevision());
+                                        revision.setComment(info.getDescription());
+                                        cvsfile.setTipRevision(revision);
+                                        for (LogInformation.Revision r : info.getRevisionList()) {
+                                                revision = CVSInfoImpl.this.FACTORY
+                                                                .createRevisionType();
+                                                revision.setRevision(r.getNumber());
+                                                revision.setComment(r.getMessage());
+                                                cvsfile.getRevisions().add(revision);
+                                        }
+                                        cvsfile.getAttributes().add(
+                                                        CVSInfoImpl.this.getAttribute("TOTALREVISIONS",
+                                                                        info.getTotalRevisions()));
+                                        cvsfile.getAttributes().add(
+                                                        CVSInfoImpl.this.getAttribute("BRANCH",
+                                                                        info.getBranch()));
+                                        cvsfile.getAttributes().add(
+                                                        CVSInfoImpl.this.getAttribute(
+                                                                        "KEYWORDSUBSTITUTION",
+                                                                        info.getKeywordSubstitution()));
+                                        cvsfile.getAttributes().add(
+                                                        CVSInfoImpl.this.getAttribute("LOCKS",
+                                                                        info.getLocks()));
+                                        cvsfile.getAttributes().add(
+                                                        CVSInfoImpl.this.getAttribute("SELECTEDREVISIONS",
+                                                                        info.getSelectedRevisions()));
+                                        cvsfile.setROOT(cvsclient.getRoot().host + "@"
+                                                        + cvsclient.getRoot().repository);
+                                        CVSInfoImpl.this.list.getItems().add(cvsfile);
+                                        String key = CVSClient.generateID(cvsfile);
+                                        try {
+                                                CVSInfoImpl.this.getCacheInstance().put(key, cvsfile);
+                                        } catch (CacheException e) {
+                                                CVSInfoImpl.this.logger.error("Could not cache item '"
+                                                                + key + "'", e);
+                                        }
+                                }
+                        });
+                        RlogCommand rlog = new RlogCommand();
+                        StringTokenizer tk = new StringTokenizer(modules, ",");
+                        while (tk.hasMoreTokens()) {
+                                rlog.setModule(tk.nextToken());
+                        }
+                        if (rlog.getModules().length == 0) {
+                                rlog.setModule("");
+                        }
+                        rlog.setDefaultBranch(false);
+                        rlog.setNoTags(false);
+                        rlog.setHeaderAndDescOnly(false);
+                        rlog.setRecursive(isRecursive);
+                        this.logger.info("Executing CVS command '" + rlog.getCVSCommand()
+                                        + "' against '" + cvsclient.getRoot().host + "@"
+                                        + cvsclient.getRoot().repository + "'");
+                        client.executeCommand(rlog, cvsclient.getGlobalOptions());
+                        getCacheInstance().put(cachekey, this.list);
+                } catch (ConfigurationException e) {
+                        this.logger.error("CVS Configuration File '" + f.getAbsolutePath()
+                                        + f.getName() + "'not found.", e);
+                } catch (CommandAbortedException e) {
+                        e.printStackTrace();
+                } catch (AuthenticationException e) {
+                        e.printStackTrace();
+                } catch (CommandException e) {
+                        e.printStackTrace();
+                } catch (CacheException e) {
+                        e.printStackTrace();
+                }
+                if (!showRevisions) {
+                        for (ItemType t : this.list.getItems()) {
+                                t.getRevisions().clear();
+                        }
+                }
+                return Response.ok(this.list).build();
+        }
+        public Response getModules(HttpHeaders h, File f, boolean forceNoCache) {
+                String cachekey = "Modules" + f.toURI().toString();
+                this.logger.debug("forceNoCache=" + forceNoCache);
+                ModuleListType response = (ModuleListType) getCacheInstance().get(
+                                cachekey);
+                if ((!forceNoCache) && (response != null)) {
+                        return Response.ok(response).build();
+                }
+                try {
+                        CVSClient cvsclient = new CVSClient(f);
+                        Client client = cvsclient.client;
+                        final ModuleListType list = this.FACTORY.createModuleListType();
+                        client.getEventManager().addCVSListener(new BasicCVSListener() {
+                                public void fileInfoGenerated(FileInfoEvent e) {
+                                        ModuleListInformation info = (ModuleListInformation) e
+                                                        .getInfoContainer();
+                                        ModuleType module = CVSInfoImpl.this.FACTORY
+                                                        .createModuleType();
+                                        module.setName(info.getModuleName());
+                                        module.setStatus(info.getModuleStatus());
+                                        module.setPath(info.getPaths());
+                                        module.setType(info.getType());
+                                        list.getModules().add(module);
+                                }
+                        });
+                        CheckoutCommand co = new CheckoutCommand();
+                        co.setShowModulesWithStatus(true);
+                        this.logger.info("Executing CVS command '" + co.getCVSCommand()
+                                        + "' against '" + cvsclient.getRoot().host + "@"
+                                        + cvsclient.getRoot().repository + "'");
+                        client.executeCommand(co, cvsclient.getGlobalOptions());
+                        if (list.getModules().size() == 0) {
+                                this.logger.warn("Repository '"
+                                                + cvsclient.getRoot().repository
+                                                + "' does not have modules");
+                        }
+                        getCacheInstance().put(cachekey, list);
+                        return Response.ok(list).build();
+                } catch (Exception e) {
+                        e.printStackTrace();
+                }
+                return Response.serverError().build();
+        }
+        public Response getTags(HttpHeaders h, File f, boolean withFiles) {
+                String cachekey = f.toURI().toString() + ":taglist";
+                this.logger.debug("Retrieving Tags from cache using key '" + cachekey
+                                + "'");
+                TagListType tags = (TagListType) getCacheInstance().get(cachekey);
+                if (tags != null) {
+                        this.logger.debug("Delivering Tags from cache.");
+                        return Response.ok(tags).build();
+                }
+                this.logger.warn("Taglist not found in cache.");
+                return Response.noContent().build();
+        }
+        public Response getFileContent(HttpHeaders h, File f, String filestring,
+                        boolean forceNoCache) {
+                final ItemType result = this.FACTORY.createItemType();
+                final String cachekey = f.toURI().toString() + ":" + filestring
+                                + ":content";
+                ItemListType list = null;
+                if (!forceNoCache) {
+                        this.logger.debug("Retrieving file content from cache using key '"
+                                        + cachekey + "'");
+                        list = (ItemListType) getCacheInstance().get(cachekey);
+                }
+                if (list != null) {
+                        this.logger.debug("Delivering file content from cache.");
+                        return Response.ok(list).build();
+                }
+                this.logger.warn("File content not found in cache.");
+                list = this.FACTORY.createItemListType();
+                try {
+                        CVSClient cvsclient = new CVSClient(f);
+                        Client client = cvsclient.getClient();
+                        CheckoutCommand checkout = new CheckoutCommand();
+                        BasicCVSListener listener = new BasicCVSListener() {
+                                public void fileInfoGenerated(FileInfoEvent arg0) {
+                                        System.out.println(arg0.getInfoContainer().getFile()
+                                                        .toURI().toString());
+                                        PipedFileInformation info = (PipedFileInformation) arg0
+                                                        .getInfoContainer();
+                                        result.setName(info.getFile().getName());
+                                        try {
+                                                boolean isBinary = false;
+                                                result.setIsBinary(isBinary);
+                                                result.setRemotename(info.getRepositoryFileName());
+                                                RevisionType revision = CVSInfoImpl.this.FACTORY
+                                                                .createRevisionType();
+                                                revision.setRevision(info.getRepositoryRevision());
+                                                revision.setComment("");
+                                                if (!isBinary) {
+                                                        FileReader fin = new FileReader(info.getTempFile());
+                                                        ByteArrayOutputStream bout = new ByteArrayOutputStream();
+                                                        StringBuffer sbuf = new StringBuffer();
+                                                        int c;
+                                                        while ((c = fin.read()) != -1) {
+                                                                bout.write(c);
+                                                                sbuf.append((char) c);
+                                                        }
+                                                        result.setData(bout.toByteArray());
+                                                        result.setContent(sbuf.toString());
+                                                }
+                                        } catch (IOException e2) {
+                                                e2.printStackTrace();
+                                        } catch (NullPointerException ne) {
+                                                ne.printStackTrace();
+                                        }
+                                        String key = CVSClient.generateID(result);
+                                        try {
+                                                CVSInfoImpl.this.getCacheInstance().put(cachekey,
+                                                                result);
+                                        } catch (CacheException e1) {
+                                                e1.printStackTrace();
+                                        }
+                                }
+                        };
+                        client.getEventManager().addCVSListener(listener);
+                        checkout.setModule(filestring);
+                        checkout.setPipeToOutput(true);
+                        this.logger.info("Execute CVS command '" + checkout.getCVSCommand()
+                                        + "' against '" + cvsclient.getRoot().host + "@"
+                                        + cvsclient.getRoot().repository + "'");
+                        client.executeCommand(checkout, cvsclient.getGlobalOptions());
+                } catch (CommandAbortedException e) {
+                        e.printStackTrace();
+                } catch (ConfigurationException e) {
+                        e.printStackTrace();
+                } catch (AuthenticationException e) {
+                        e.printStackTrace();
+                } catch (CommandException e) {
+                        e.printStackTrace();
+                }
+                if (result.getContent() != null) {
+                        return Response.ok(result).build();
+                }
+                return Response.noContent().build();
+        }
+        public JCS getCacheInstance() {
+                JCS jcs = null;
+                String cacheinstance = "CVSCache";
+                try {
+                        this.logger.trace("Getting cache instance named 'CVSCache'");
+                        jcs = JCS.getInstance("CVSCache");
+                } catch (CacheException e) {
+                        this.logger.error("Failed to get cache instance", e);
+                        e.printStackTrace();
+                }
+                return jcs;
+        }
+        public Response searchFileContent(HttpHeaders h, File f,
+                        String file_regexp, String content_regexp, boolean forceNoCache) {
+                try {
+                        CVSClient client = new CVSClient(f);
+                        String cvsroot = client.getRoot().host + "@"
+                                        + client.getRoot().repository;
+                        String cachestring = "FINDINGS-" + cvsroot;
+                        this.logger
+                                        .debug("Fetch searchFileContent response from cache using cachekey '"
+                                                        + cachestring + "'");
+                        FindingsListType result = (FindingsListType) getCacheInstance()
+                                        .get(cachestring);
+                        if (result != null)
+                                this.logger.debug("Found object for key '" + cachestring
+                                                + "' in cache.");
+                        else {
+                                this.logger.debug("Found no object for key '" + cachestring
+                                                + "' in cache.");
+                        }
+                        if (result != null)
+                                return Response.ok(result).build();
+                } catch (CommandAbortedException e) {
+                        e.printStackTrace();
+                } catch (ConfigurationException e) {
+                        e.printStackTrace();
+                } catch (AuthenticationException e) {
+                        e.printStackTrace();
+                }
+                return Response.noContent().build();
+        }
+        private AttributeType getAttribute(String name, String value) {
+                AttributeType attribute = this.FACTORY.createAttributeType();
+                attribute.setName(name);
+                attribute.setValue(value);
+                return attribute;
+        }
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /xservices/trunk/src/java/net/brutex/xservices/ws/StringService.java
 ,0 → 1,84
+/*
+ *   Copyright 2013 Brian Rosenberger (Brutex Network)
+ *
+ *   Licensed 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 net.brutex.xservices.ws;
+import java.util.ArrayList;
+import javax.jws.WebMethod;
+import javax.jws.WebParam;
+import javax.jws.WebService;
+import javax.xml.bind.annotation.XmlElement;
+import net.brutex.xservices.types.StringMatchType;
+import net.brutex.xservices.types.StringReplaceType;
+import net.brutex.xservices.types.StringSplitType;
+import org.apache.cxf.annotations.WSDLDocumentation;
+/**
+ * @author Brian Rosenberger, bru(at)brutex.de
+ *
+ */
+@WebService(targetNamespace="http://ws.xservices.brutex.net")
+public abstract interface StringService
+{
+  public static final String SERVICE_NAME = "StringService";
+  public static final String OPERATION_REPLACEREGEX = "replaceRegEx";
+  public static final String OPERATION_MATCHREGEX = "matchRegEx";
+  public static final String OPERATION_ENCODETOENTITIES = "encodeToXMLEntities";
+  public static final String PARAM_STRING = "string";
+  public static final String PARAM_SEARCH = "search";
+  public static final String PARAM_REPLACE = "replace";
+  public static final String PARAM_FLAGS = "regexflags";
+  @WebMethod(operationName="replaceRegEx")
+  @WSDLDocumentation("Store text based data")
+  public abstract StringReplaceType replaceRegEx(
+                  @WebParam(name="string") String paramString1,
+                  @WebParam(name="search") String paramString2,
+                  @WebParam(name="replace") String paramString3,
+                  @WebParam(name="regexflags") String paramString4)
+    throws XServicesFault;
+  @WebMethod(operationName="matchRegEx")
+  @WSDLDocumentation("Match text based data")
+  public abstract StringMatchType matchRegEx(
+                  @WebParam(name="string") String paramString1,
+                  @WebParam(name="search") String paramString2,
+                  @WebParam(name="regexflags") String paramString3)
+    throws XServicesFault;
+  @WebMethod(operationName="encodeToXMLEntities")
+  @WSDLDocumentation("Match text based data")
+  public abstract String encodeToXMLEntities(
+                  @WebParam(name="string") @XmlElement(required=true) String paramString)
+    throws XServicesFault;
+  @WebMethod(operationName="splitString")
+  @WSDLDocumentation("Split a string into tokens")
+  public abstract StringSplitType splitString(
+                  @WebParam(name="string") @XmlElement(required=true) String paramString,
+                  @WebParam(name="delimiter") @XmlElement(required=true) String delimiter)
+        throws XServicesFault;
+  @WebMethod(operationName="removeCRLF")
+  @WSDLDocumentation("Remove any line feed and/ or carriage return characters")
+  public abstract String removeCRLF(
+                  @WebParam(name="string") @XmlElement(required=true) String paramString)
+        throws XServicesFault;
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /xservices/trunk/src/java/net/brutex/xservices/ws/FileService.java
 ,0 → 1,255
+/*
+ *   Copyright 2010 Brian Rosenberger (Brutex Network)
+ *
+ *   Licensed 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 net.brutex.xservices.ws;
+import java.util.List;
+import javax.jws.WebMethod;
+import javax.jws.WebParam;
+import javax.jws.WebService;
+import javax.xml.bind.annotation.XmlElement;
+import org.apache.cxf.annotations.WSDLDocumentation;
+import org.apache.cxf.annotations.WSDLDocumentationCollection;
+import net.brutex.xservices.types.ReplacePattern;
+import net.brutex.xservices.types.ReturnCode;
+import net.brutex.xservices.types.ant.ArchiveResource;
+import net.brutex.xservices.types.ant.AttachmentType;
+import net.brutex.xservices.types.ant.FileResource;
+import net.brutex.xservices.types.ant.FileSetResource;
+import net.brutex.xservices.util.BrutexNamespaces;
+import net.brutex.xservices.util.XServicesDocumentation;
+/**
+ * File related web service operations.
+ *
+ * @author Brian Rosenberger
+ * @since 0.3.0
+ *
+ */
+@WebService(targetNamespace = BrutexNamespaces.WS_XSERVICES)
+@WSDLDocumentationCollection(
+    {
+        @WSDLDocumentation(value = BrutexNamespaces.BRUTEX_COPYRIGHT, placement = WSDLDocumentation.Placement.TOP)
+    }
+)
+public interface FileService {
+        final String OPERATION_BASENAME ="basename";
+        final String OPERATION_DOWNLOADFILE ="downloadFile";
+        final String OPERATION_UPLOADFILE ="uploadFile";
+        final String OPERATION_COPY ="copy";
+        final String OPERATION_COPYFILE ="copyFile";
+        final String OPERATION_LOADRESOURCE = "loadResource";
+        final String OPERATION_LOADRESOURCEFROMARCHIVE = "loadResourceFromArchive";
+        final String OPERATION_ECHOTOFILE = "echoToFile";
+        final String OPERATION_CHANGEOWNER = "changeOwner";
+        final String OPERATION_CHANGEMODE = "changeMode";
+        final String OPERATION_CHANGEGROUP = "changeGroup";
+        final String OPERATION_REPLACEINFILE = "replaceInFile";
+        final String OPERATION_REPLACEINFILE2 = "replaceInFile2";
+        final String OPERATION_REPLACEINFILEREGEX = "replaceInFileRegEx";
+        final String PARAM_FILE = "file";
+        final String PARAM_ENCODING = "encoding";
+        final String PARAM_OVERRIDE = "override";
+        /**
+         * @param filename
+         * @param suffix
+         * @return The base name of the given file excluding the suffix.
+         */
+        @WSDLDocumentation(value = "The base name of the given file excluding the suffix.")
+        @WebMethod(operationName = OPERATION_BASENAME)
+        public abstract String basename(
+                        @WebParam(name = PARAM_FILE) @XmlElement(required=true) String filename,
+                        @WebParam(name = "suffix") String suffix);
+        /**
+         * @param res
+         * @return The file itself (MTOM attachment or inline base64) including some file metadata.
+         * @throws XServicesFault
+         */
+        @WSDLDocumentation(XServicesDocumentation.SERVICE_OPERATION_DOWNLOADFILE)
+        @WebMethod(operationName = OPERATION_DOWNLOADFILE)
+        public abstract AttachmentType downloadFile(
+                        @WebParam(name = FileResource.XML_NAME) FileResource res) throws XServicesFault;
+        /**
+         * @param file
+         * @return The file name of the file that has been uploaded.
+         * @throws XServicesFault
+         */
+        @WSDLDocumentation(XServicesDocumentation.SERVICE_OPERATION_UPLOADFILE)
+        @WebMethod(operationName = OPERATION_UPLOADFILE)
+        public abstract String uploadFile(
+                        @WebParam(name = PARAM_FILE) AttachmentType file) throws XServicesFault;
+        /**
+         * @param src
+         * @param todir
+         * @param plm
+         * @param overwrite
+         * @param encoding
+         * @return
+         * @throws XServicesFault
+         */
+        @WSDLDocumentation(value = XServicesDocumentation.SERVICE_OPERATION_COPY)
+        @WebMethod(operationName = OPERATION_COPY)
+        public abstract ReturnCode copy(
+                        @WebParam(name =  FileSetResource.XML_NAME) @XmlElement(required=true) FileSetResource src,
+                        @WebParam(name = "todir") @XmlElement(required=true) String todir,
+                        @WebParam(name = "preservelastmodified") boolean plm,
+                        @WebParam(name = PARAM_OVERRIDE) boolean overwrite,
+                        @WebParam(name = PARAM_ENCODING) String encoding) throws XServicesFault;
+        /**
+         * @param fromFile
+         * @param tofile
+         * @param overwrite
+         * @return
+         * @throws XServicesFault
+         */
+        @WSDLDocumentation(value = XServicesDocumentation.SERVICE_OPERATION_COPYFILE)
+        @WebMethod(operationName = OPERATION_COPYFILE)
+        public abstract ReturnCode copyFile(
+                        @WebParam(name = "fromFile") @XmlElement(required=true) String fromFile,
+                        @WebParam(name = "toFile") @XmlElement(required=true) String tofile,
+                        @WebParam(name = PARAM_OVERRIDE) boolean overwrite) throws XServicesFault;
+        /**
+         * @param res
+         * @param encoding
+         * @return content of the resource
+         * @throws XServicesFault
+         */
+        @WSDLDocumentation(value = XServicesDocumentation.SERVICE_OPERATION_LOADRESOURCE)
+        @WebMethod(operationName = OPERATION_LOADRESOURCE)
+        public abstract String loadRes(
+                        @WebParam(name = FileResource.XML_NAME) FileResource res,
+                        @WebParam(name = PARAM_ENCODING) String encoding) throws XServicesFault;
+        /**
+         * @param res
+         * @param encoding
+         * @return content of the resource
+         * @throws XServicesFault
+         */
+        @WSDLDocumentation(value = XServicesDocumentation.SERVICE_OPERATION_LOADRESOURCEFROMARCHIVE)
+        @WebMethod(operationName = OPERATION_LOADRESOURCEFROMARCHIVE)
+        public abstract String loadResFromArchive(
+                        @WebParam(name = "archiveresource") ArchiveResource res,
+                        @WebParam(name = PARAM_ENCODING) String encoding) throws XServicesFault;
+        /**
+         * @param message
+         * @param file
+         * @param encoding
+         * @param append
+         * @param create
+         * @return
+         * @throws XServicesFault
+         */
+        @WSDLDocumentation(value = XServicesDocumentation.SERVICE_OPERATION_ECHOTOFILE)
+        @WebMethod(operationName = OPERATION_ECHOTOFILE)
+        public abstract ReturnCode echo2file(
+                        @WebParam(name = "message") @XmlElement(required=true) String message,
+                        @WebParam(name = PARAM_FILE) @XmlElement(required=true) String file,
+                        @WebParam(name = PARAM_ENCODING) String encoding,
+                        @WebParam(name = "append") boolean append,
+                        @WebParam(name = "create") boolean create) throws XServicesFault;
+        /**
+         * Changes the owner of a file or all files inside specified directories.
+         * Right now it has effect only under Unix/ Linux as it is implemented through
+         * the 'chown' command.
+         *
+         * @param res Collection of files/ directories
+         * @param owner Identifier of the new owner
+         * @return
+         */
+        @WebMethod(operationName = OPERATION_CHANGEOWNER)
+        public abstract ReturnCode changeOwner(
+                        @WebParam(name =  FileSetResource.XML_NAME) FileSetResource res,
+                        @WebParam(name = "owner") @XmlElement(required=true) String owner);
+        /**
+         * Changes the group owner of a file or all files inside specified directories.
+         * Right now it has effect only under Unix/ Linux as it is implemented through
+         * the 'chgrp' command.
+         *
+         * @param res Collection of files/ directories
+         * @param group Identifier of the new group owner
+         * @return
+         */
+        @WebMethod(operationName = OPERATION_CHANGEGROUP)
+        public abstract ReturnCode changeGroup(
+                        @WebParam(name =  FileSetResource.XML_NAME) FileSetResource res,
+                        @WebParam(name = "group") @XmlElement(required=true) String group);
+        /**
+         * @param res
+         * @param perm
+         * @return
+         */
+        @WebMethod(operationName = OPERATION_CHANGEMODE)
+        public abstract ReturnCode changeMode(
+                        @WebParam(name = FileSetResource.XML_NAME) FileSetResource res,
+                        @WebParam(name = "permissions") @XmlElement(required=true) String perm);
+        /**
+         * @param res
+         * @param search
+         * @param replace
+         * @return
+         * @throws XServicesFault
+         */
+        @WSDLDocumentation(value = XServicesDocumentation.SERVICE_OPERATION_REPLACEINFILE)
+        @WebMethod(operationName = OPERATION_REPLACEINFILE)
+        public abstract ReturnCode replaceInFile(
+                        @WebParam(name = FileResource.XML_NAME) @XmlElement(required=true) FileResource res,
+                        @WebParam(name = "search") @XmlElement(required=true) String search,
+                        @WebParam(name = "replace") @XmlElement(required=true) String replace) throws XServicesFault;
+        /**
+         * @param res
+         * @param patternList
+         * @return
+         * @throws XServicesFault
+         */
+        @WSDLDocumentation(value = XServicesDocumentation.SERVICE_OPERATION_REPLACEINFILE2)
+        @WebMethod(operationName = OPERATION_REPLACEINFILE2)
+        public abstract ReturnCode replaceInFile2(
+                        @WebParam(name = FileResource.XML_NAME) FileResource res,
+                        @WebParam(name = "patternList") List<ReplacePattern> patternList) throws XServicesFault;
+        /**
+         * @param res
+         * @param search
+         * @param replace
+         * @param flags
+         * @return
+         * @throws XServicesFault
+         */
+        @WSDLDocumentation(value = XServicesDocumentation.SERVICE_OPERATION_REPLACEINFILEREGEX)
+        @WebMethod(operationName = OPERATION_REPLACEINFILEREGEX)
+        public abstract ReturnCode replaceInFileRegEx(
+                        @WebParam(name = FileResource.XML_NAME) FileResource res,
+                        @WebParam(name = "search") String search,
+                        @WebParam(name = "replace") String replace,
+                        @WebParam(name = "flags") String flags) throws XServicesFault;
+}

 /xservices/trunk/src/java/net/brutex/xservices/ws/JobService.java
 ,0 → 1,97
+/*
+ *   Copyright 2011 Brian Rosenberger (Brutex Network)
+ *
+ *   Licensed 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 net.brutex.xservices.ws;
+import java.util.List;
+import javax.jws.WebMethod;
+import javax.jws.WebParam;
+import javax.jws.WebService;
+import javax.xml.bind.annotation.XmlElement;
+import net.brutex.xservices.types.ScheduledJob;
+import net.brutex.xservices.util.BrutexNamespaces;
+import org.apache.cxf.annotations.WSDLDocumentation;
+/**
+ * Job management services.
+ * @author Brian Rosenberger
+ * @since 0.5.0
+ *
+ */
+@WebService(targetNamespace = BrutexNamespaces.WS_XSERVICES)
+public interface JobService {
+        public static final String SERVICE_NAME = "JobService";
+        final String OPERATION_GETJOBLIST = "getJobs";
+        final String OPERATION_SCHEDULEJOB = "scheduleJob";
+        final String OPERATION_GETJOB = "getJob";
+        final String OPERATION_DELETEJOB = "deleteJob";
+        final String PARAM_JOB = "job";
+        /**
+         * Get a full list of all scheduled jobs.
+         *
+         * @return List of scheduled jobs
+         * @throws XServicesFault
+         */
+        @WebMethod(operationName=OPERATION_GETJOBLIST)
+        @WSDLDocumentation(value="Get list of scheduled jobs")
+        public abstract List<ScheduledJob> getJobList() throws XServicesFault;
+        /**
+         * Add a job to the scheduler.
+         *
+         * @param job
+         * @return The unique identifier of the job.
+         * @throws XServicesFault
+         */
+        @WebMethod(operationName=OPERATION_SCHEDULEJOB)
+        @WSDLDocumentation(value="Schedule a job")
+        public abstract String scheduleJob(
+                        @WebParam(name=PARAM_JOB) @XmlElement(required=true) ScheduledJob job)
+                        throws XServicesFault;
+        /**
+         * Get a job by id.
+         *
+         * @param uuid
+         * @return Job details
+         * @throws XServicesFault
+         */
+        @WebMethod(operationName=OPERATION_GETJOB)
+        @WSDLDocumentation(value="Get a job by id")
+        public abstract ScheduledJob getJob(
+                        @WebParam(name="id") @XmlElement(required=true) String uuid) throws XServicesFault;
+        /**
+         * Delete a job from scheduler.
+         *
+         * @param uuid Id of the job that should be deleted
+         * @throws XServicesFault
+         */
+        @WebMethod(operationName=OPERATION_DELETEJOB)
+        @WSDLDocumentation(value="Delete a scheduled job.")
+        public abstract void deleteJob(
+                        @WebParam(name="id") @XmlElement(required=true) String uuid) throws XServicesFault;
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /xservices/trunk/src/java/net/brutex/xservices/ws/MiscService.java
 ,0 → 1,63
+/*
+ *   Copyright 2013 Brian Rosenberger (Brutex Network)
+ *
+ *   Licensed 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 net.brutex.xservices.ws;
+import javax.jws.WebMethod;
+import javax.jws.WebParam;
+import javax.jws.WebService;
+import net.brutex.xservices.types.HostConnection;
+import net.brutex.xservices.types.HostinfoType;
+import net.brutex.xservices.types.MailMimeType;
+import net.brutex.xservices.types.ReturnCode;
+import net.brutex.xservices.types.RuntimeInfoType;
+import net.brutex.xservices.types.ant.FileSetResource;
+import org.apache.cxf.aegis.type.java5.XmlElement;
+import org.apache.cxf.aegis.type.java5.XmlReturnType;
+import org.apache.cxf.annotations.WSDLDocumentation;
+/**
+ * Bundles various methods
+ *
+ * @author Brian Rosenberger, bru@brutex.de
+ * @since 0.4.0
+ */
+@WebService(targetNamespace = net.brutex.xservices.util.BrutexNamespaces.WS_XSERVICES)
+@WSDLDocumentation("Various service operations.")
+public interface MiscService {
+         public static final String OPERATION_GETMEMORY = "getMemory";
+          @WebMethod(operationName="getHostinfo")
+          @WSDLDocumentation("Get information about a host.")
+          public abstract HostinfoType getHostinfo(@WebParam(name="hostname") @XmlElement(minOccurs="1", nillable=false) String paramString);
+          @WebMethod(operationName="sleep")
+          @WSDLDocumentation("Delay request response a specified duration.")
+          public abstract ReturnCode sleep(@WebParam(name="minutes") int paramInt1, @WebParam(name="seconds") int paramInt2);
+          @WebMethod(operationName="getInfo")
+          @WSDLDocumentation("Get XService information.")
+          public abstract ReturnCode getInfo();
+          @WebMethod(operationName="generateUUID")
+          @WSDLDocumentation("Generate a UUID.")
+          public abstract String generateUUID();
+          @WebMethod(operationName="getMemory")
+          @WSDLDocumentation("Get memory and processor information")
+          public abstract RuntimeInfoType getMemory();
+}

 /xservices/trunk/src/java/net/brutex/xservices/ws/MailService.java
 ,0 → 1,123
+/*
+ *   Copyright 2012 Brian Rosenberger (Brutex Network)
+ *
+ *   Licensed 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 net.brutex.xservices.ws;
+import javax.jws.WebMethod;
+import javax.jws.WebParam;
+import javax.jws.WebService;
+import javax.xml.bind.annotation.XmlElement;
+import net.brutex.xservices.types.HostConnection;
+import net.brutex.xservices.types.MailMimeType;
+import net.brutex.xservices.types.ReturnCode;
+import net.brutex.xservices.types.ant.FileSetResource;
+import net.brutex.xservices.util.BrutexNamespaces;
+import org.apache.cxf.annotations.WSDLDocumentation;
+/**
+ * Bundles various method for sending and receiving mails
+ *
+ * @author Brian Rosenberger, bru@brutex.de
+ * @since 2.0.0
+ */
+@WebService(targetNamespace = BrutexNamespaces.WS_XSERVICES)
+@WSDLDocumentation("Various mail service operations.")
+public interface MailService {
+    final String PARAM_SMTPHOST = "mailhost";
+    final String PARAM_SENDER = "from";
+    final String PARAM_RECEIVER = "to";
+    final String PARAM_SUBJECT = "subject";
+    final String PARAM_MESSAGE = "message";
+    final String PARAM_ATTACHMENTS = "attachments";
+    /**
+     * Simple mail send operation with sender, single receiver, subject and message.
+     *
+     * @param mailhost  connection details for the SMTP server to use
+     * @param from              mail address to be used as sender
+     * @param tolist    mail address of the receiver
+     * @param subject   subject of the mail
+     * @param message   mail body
+     * @return ReturnCode
+     */
+    @WebMethod(operationName = "sendMailSimple")
+    @WSDLDocumentation(value = "Send an email (simple).")
+    public ReturnCode sendMailSimple(
+                @WebParam(name = PARAM_SMTPHOST) @XmlElement(required=true, nillable=false) HostConnection mailhost,
+            @WebParam(name = PARAM_SENDER) @XmlElement(required=true) String from,
+            @WebParam(name = PARAM_RECEIVER) @XmlElement(required=true, nillable=false) String tolist,
+            @WebParam(name = PARAM_SUBJECT) String subject,
+            @WebParam(name = PARAM_MESSAGE) String message);
+    /**
+     * Simple mail send operation with sender, single receiver, subject and message
+     * including support for file attachments.
+     *
+     * @param mailhost  connection details for the SMTP server to use
+     * @param from              mail address to be used as sender
+     * @param tolist    mail address of the receiver
+     * @param subject   subject of the mail
+     * @param message   mail body
+     * @param res               attachments
+     * @return ReturnCode
+     */
+    @WebMethod(operationName = "sendMailSimpleWithAttachment")
+    @WSDLDocumentation(value = "Send an email with attachment (simple).")
+    public ReturnCode sendMailSimpleWithAttachment(
+                @WebParam(name = PARAM_SMTPHOST) @XmlElement(required=true, nillable=false) HostConnection mailhost,
+            @WebParam(name = PARAM_SENDER) @XmlElement(required=true, nillable=false) String from,
+            @WebParam(name = PARAM_RECEIVER) @XmlElement(required=true, nillable=false) String tolist,
+            @WebParam(name = PARAM_SUBJECT) String subject,
+            @WebParam(name = PARAM_MESSAGE) String message,
+            @WebParam(name = PARAM_ATTACHMENTS) FileSetResource res);
+    /**
+     * Send email with a lot of options
+     *
+     * @param mailhost  connection details for the SMTP server to use
+     * @param from              mail address to be used as sender
+     * @param tolist    mail address of the receiver
+     * @param cclist    mail carbon copy receiver
+     * @param bcclist   mail blind carbon copy receiver
+     * @param subject   subject of the mail
+     * @param mimetype  message MIME type (i.e. text/plain)
+     * @param charset   character set to use (i.e. utf-8, iso-8859-15)
+     * @param message   mail body
+     * @param res               attachments
+     * @param ssl               use SSL
+     * @param tls               use TLS
+     * @return ReturnCode
+     */
+    @WebMethod(operationName = "sendMail")
+    @WSDLDocumentation(value = "Send an email (advanced).")
+    public ReturnCode sendMail(
+                @WebParam(name = PARAM_SMTPHOST) @XmlElement(required=true, nillable=false) HostConnection mailhost,
+            @WebParam(name = PARAM_SENDER) @XmlElement(required=true, nillable=false) String from,
+            @WebParam(name = PARAM_RECEIVER) @XmlElement(required=true, nillable=false) String tolist,
+            @WebParam(name = "cc") String cclist,
+            @WebParam(name = "bcc") String bcclist,
+            @WebParam(name = PARAM_SUBJECT) String subject,
+            @WebParam(name = "mimetype") MailMimeType mimetype,
+            @WebParam(name = "charset") String charset,
+            @WebParam(name = PARAM_MESSAGE) String message,
+            @WebParam(name = PARAM_ATTACHMENTS) FileSetResource res,
+            @WebParam(name = "useSSL") boolean ssl,
+            @WebParam(name = "useStartTLS") boolean tls);
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /xservices/trunk/src/java/net/brutex/xservices/ws/XServicesFault.java
 ,0 → 1,99
+/*
+ *   Copyright 2010 Brian Rosenberger (Brutex Network)
+ *
+ *   Licensed 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 net.brutex.xservices.ws;
+import java.util.GregorianCalendar;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlRootElement;
+import javax.xml.bind.annotation.XmlType;
+import javax.xml.datatype.DatatypeConfigurationException;
+import javax.xml.datatype.DatatypeFactory;
+import javax.xml.datatype.XMLGregorianCalendar;
+import javax.xml.ws.WebFault;
+import net.brutex.xservices.util.BrutexNamespaces;
+/**
+ * Generic web service fault.
+ *
+ * @author Brian Rosenberger, bru@brutex.de
+ * since 0.4.0
+ */
+@WebFault(targetNamespace=BrutexNamespaces.WS_XSERVICES)
+public class XServicesFault extends Exception {
+    /**
+         *
+         */
+        private static final long serialVersionUID = -6779279189376374820L;
+        public XServicesFault(String message, Exception e) {
+        this(message, e.getCause());
+    }
+    public XServicesFault(String string) {
+        this(string, new Exception(string).getCause());
+    }
+    public XServicesFault(Exception e) {
+        this(e.getMessage(), e.getCause());
+    }
+    public XServicesFault(String message, Throwable cause) {
+        super(message, cause);
+        this.faultstring=message;
+        try {
+            timestamp = DatatypeFactory.newInstance().newXMLGregorianCalendar(new GregorianCalendar());
+        } catch (DatatypeConfigurationException ex) {
+            System.err.println(ex.getMessage());
+        }
+    }
+    /**
+     * The error message.
+     */
+    @XmlElement(name="faultstring", namespace=BrutexNamespaces.WS_XSERVICES)
+    public String faultstring = "";
+    /**
+     * Username under which the web service has been executed.
+     */
+    @XmlElement(name="username", namespace=BrutexNamespaces.WS_XSERVICES)
+    public String username = System.getProperty("user.name");
+    /**
+     * Home directory of the user profile running the web service.
+     */
+    @XmlElement(name="homedir", namespace=BrutexNamespaces.WS_XSERVICES)
+    public String homedir = System.getProperty("user.home");
+    /**
+     * Timestamp when the fault was thrown.
+     */
+    @XmlElement(name="timstamp", namespace=BrutexNamespaces.WS_XSERVICES)
+    public XMLGregorianCalendar timestamp = null;
+    /**
+     * Java runtime version.
+     */
+    @XmlElement(name="jvmversion")
+    public String jvmruntime = System.getProperty("java.version");
+}

 /xservices/trunk/src/java/net/brutex/xservices/ws/StorageService.java
 ,0 → 1,84
+/*
+ *   Copyright 2011 Brian Rosenberger (Brutex Network)
+ *
+ *   Licensed 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 net.brutex.xservices.ws;
+import javax.jws.WebMethod;
+import javax.jws.WebParam;
+import javax.jws.WebService;
+import net.brutex.xservices.types.TargetNodeType;
+import net.brutex.xservices.types.ant.AttachmentType;
+import net.brutex.xservices.types.ant.CollectionType;
+import net.brutex.xservices.util.BrutexNamespaces;
+import org.apache.cxf.annotations.WSDLDocumentation;
+/**
+ * Storage management services.
+ * @author Brian Rosenberger
+ * @since 0.5.0
+ *
+ */
+@WebService(targetNamespace = BrutexNamespaces.WS_XSERVICES)
+public interface StorageService {
+        public static final String SERVICE_NAME = "StorageService";
+        final String OPERATION_STORETEXT = "storeText";
+        final String OPERATION_STOREBINARY = "storeBinary";
+        final String OPERATION_CREATECOLLECTION = "createCollection";
+        final String OPERATION_DELIVERCOLLECTION = "deliverCollection";
+        final String PARAM_TEXT = "text";
+        final String PARAM_BINARY = "binary";
+        final String PARAM_NAME = "name";
+        final String PARAM_COLLECTION = "collection";
+        final String PARAM_TARGETNODE = "target";
+        final String PARAM_RAISEEVENT = "event";
+                ;
+        /**
+         * Store text based data.
+         * @param text text to be stored
+         *
+         * @return uuid reference to stored object
+         * @throws XServicesFault
+         */
+        @WebMethod(operationName=OPERATION_STORETEXT)
+        @WSDLDocumentation(value="Store text based data")
+        public abstract String storeText(@WebParam(name = PARAM_TEXT) String text) throws XServicesFault;
+        @WebMethod(operationName=OPERATION_STOREBINARY)
+        @WSDLDocumentation(value="Store binary data")
+        public abstract String storeBinary(
+                                @WebParam(name= PARAM_BINARY) AttachmentType binary)
+                                throws XServicesFault;
+        @WebMethod(operationName=OPERATION_CREATECOLLECTION)
+        @WSDLDocumentation(value="Create a new Collection by name.")
+        public abstract String createCollection(
+                                @WebParam(name= PARAM_COLLECTION) CollectionType collection)
+                                throws XServicesFault;
+        @WebMethod(operationName=OPERATION_DELIVERCOLLECTION)
+        @WSDLDocumentation(value="Deliver a collection to a target node (asynchronous).")
+        public abstract void deliverCollection(
+                                @WebParam(name= PARAM_COLLECTION) CollectionType collection,
+                                @WebParam(name= PARAM_TARGETNODE) TargetNodeType targetnode,
+                                @WebParam(name= PARAM_RAISEEVENT) boolean isFiring)
+                                throws XServicesFault;
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /xservices/trunk/src/java/net/brutex/xservices/ws/DateService.java
 ,0 → 1,255
+/*
+ *   Copyright 2011 Brian Rosenberger (Brutex Network)
+ *
+ *   Licensed 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 net.brutex.xservices.ws;
+import java.math.BigInteger;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.List;
+import javax.jws.WebMethod;
+import javax.jws.WebParam;
+import javax.jws.WebService;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.datatype.XMLGregorianCalendar;
+import net.brutex.xservices.types.DateFormatType;
+import net.brutex.xservices.types.DateInfoExtendedType;
+import net.brutex.xservices.types.DateInfoType;
+import net.brutex.xservices.types.DateTimeUnits;
+import net.brutex.xservices.types.TimeZoneType;
+import net.brutex.xservices.util.BrutexNamespaces;
+import org.apache.cxf.annotations.WSDLDocumentation;
+import org.apache.cxf.annotations.WSDLDocumentationCollection;
+/**
+ * Date and time related services.
+ * @author Brian Rosenberger
+ *
+ */
+@WebService(targetNamespace = BrutexNamespaces.WS_XSERVICES)
+@WSDLDocumentationCollection(
+    {
+        @WSDLDocumentation(value = BrutexNamespaces.BRUTEX_COPYRIGHT, placement = WSDLDocumentation.Placement.TOP)
+    }
+)
+public interface DateService {
+        public static final String SERVICE_NAME = "DateService";
+        final String OPERATION_GETDATE = "getDate";
+        final String OPERATION_GETDATEEXTENDED = "getDateExtended";
+        final String OPERATION_GETTIMESTAMP = "getTimestamp";
+        final String OPERATION_GETTIMESTAMP2 = "getTimestamp2";
+        final String OPERATION_GETINTIMEZONE = "getInTimezone";
+        final String OPERATION_FORMATDATE = "formatDate";
+        final String OPERATION_FORMATDATEADVANCED = "formatDateAdvanced";
+        final String OPERATION_PARSEDATE = "parseDate";
+        final String OPERATION_PARSEDATEADVANCED = "parseDateAdvanced";
+        final String OPERATION_DATETIMEDIFF = "dateTimeDiff";
+        final String OPERATION_DATETIMEDIFF2 = "dateTimeDiff2";
+        final String OPERATION_DATEADD = "dateAdd";
+        final String OPERATION_GETTIMEZONES = "getTimezones";
+        final String PARAM_TIMEZONE = "timezone";
+        final String PARAM_DATETIME = "datetime";
+        final String PARAM_FORMAT = "format";
+        final String PARAM_UNIT = "unit";
+        /**
+         * Get current date and time.
+         *
+         * @return Current date and time.
+         * @throws XServicesFault
+         */
+        @WebMethod(operationName=OPERATION_GETDATE)
+        @WSDLDocumentation(value="Get current date and time.")
+        public abstract DateInfoType getDate()
+                        throws XServicesFault;
+        /**
+         * Get current date and time (extended version).
+         *
+         * @return Current date and time.
+         * @throws XServicesFault
+         */
+        @WebMethod(operationName=OPERATION_GETDATEEXTENDED)
+        @WSDLDocumentation(value="Get current date and time in different formats.")
+        public abstract DateInfoExtendedType getDateExtended()
+                        throws XServicesFault;
+        /**
+         * Get milliseconds since 01.01.1970.
+         *
+         * @return timestamp milliseconds
+         */
+        @WebMethod(operationName=OPERATION_GETTIMESTAMP)
+        @WSDLDocumentation(value="Get milliseconds since 01.01.1970 (Unix timestap).")
+        public abstract BigInteger getTimestamp();
+        /**
+         * Get seconds since 01.01.1970.
+         *
+         * @return timestamp seconds
+         */
+        @WebMethod(operationName=OPERATION_GETTIMESTAMP2)
+        @WSDLDocumentation(value="Get seconds since 01.01.1970 (Unix timestap).")
+        public abstract BigInteger getTimestamp2();
+        /**
+         * Display a date time with a different time zone.
+         * Changes representation only (no conversion).
+         *
+         * @param cal date time.
+         * @param timezone time zone
+         * @return date time
+         * @throws XServicesFault
+         */
+        @WebMethod(operationName=OPERATION_GETINTIMEZONE)
+        public abstract String getInTimezone(
+                        @WebParam(name=PARAM_DATETIME) @XmlElement(required=true) Date cal,
+                        @WebParam(name=PARAM_TIMEZONE) @XmlElement(required=true) String timezone) throws XServicesFault;
+        /**
+         * Formats a date with pre-defined patterns.
+         *
+         * @param cal date time to be formatted in ISO8601
+         * @param format Pattern to be used for date formating
+         * @return formatted date/time string
+         * @throws XServicesFault
+         */
+        @WebMethod(operationName=OPERATION_FORMATDATE)
+        public abstract String formatDate(
+                        @WebParam(name=PARAM_DATETIME) @XmlElement(required=true) Date cal,
+                        @WebParam(name=PARAM_FORMAT) @XmlElement(required=true) DateFormatType format) throws XServicesFault;
+        @WebMethod(operationName=OPERATION_GETTIMEZONES)
+        public abstract List<TimeZoneType> getTimezones() throws XServicesFault;
+        /**
+         * Formats a date with a free form pattern.
+         * Uses SimpleDateFormat patterns
+         * The following pattern letters are defined (all other characters from 'A' to 'Z' and from 'a' to 'z' are reserved):
+    Letter      Date or Time Component  Presentation    Examples
+    G   Era designator  Text    AD
+    y   Year    Year    1996; 96
+    M   Month in year   Month   July; Jul; 07
+    w   Week in year    Number  27
+    W   Week in month   Number  2
+    D   Day in year     Number  189
+    d   Day in month    Number  10
+    F   Day of week in month    Number  2
+    E   Day in week     Text    Tuesday; Tue
+    a   Am/pm marker    Text    PM
+    H   Hour in day (0-23)      Number  0
+    k   Hour in day (1-24)      Number  24
+    K   Hour in am/pm (0-11)    Number  0
+    h   Hour in am/pm (1-12)    Number  12
+    m   Minute in hour  Number  30
+    s   Second in minute        Number  55
+    S   Millisecond     Number  978
+    z   Time zone       General time zone       Pacific Standard Time; PST; GMT-08:00
+    Z   Time zone       RFC 822 time zone       -0800
+         * @param cal Date time to be formatted
+         * @param format Format string
+         * @return Date time formatted according to format string
+         * @throws XServicesFault
+         */
+        @WebMethod(operationName=OPERATION_FORMATDATEADVANCED)
+        public abstract String formatDateAdvanced(
+                        @WebParam(name=PARAM_DATETIME) @XmlElement(required=true) Date cal,
+                        @WebParam(name=PARAM_FORMAT) @XmlElement(required=true) String format) throws XServicesFault;
+        /**
+         * Converts a string into date using pre-defined date formats.
+         *
+         * @param s Date/ time as string
+         * @param format date format
+         * @param timezone timezone
+         * @return XML Date
+         * @throws XServicesFault
+         */
+        @WebMethod(operationName=OPERATION_PARSEDATE)
+        @WSDLDocumentation(value="Converts a string into date using pre-defined date formats.")
+        public abstract Date parseDate(
+                        @WebParam(name=PARAM_DATETIME) @XmlElement(required=true) String s,
+                        @WebParam(name=PARAM_FORMAT) @XmlElement(required=true) DateFormatType format,
+                        @WebParam(name=PARAM_TIMEZONE) String timezone) throws XServicesFault;
+        /**
+         * Converts a string into date using any format.
+         * @param s date/ time as string
+         * @param format date format
+         * @param timezone timezone
+         * @return XML Date
+         * @throws XServicesFault
+         */
+        @WebMethod(operationName=OPERATION_PARSEDATEADVANCED)
+        public abstract GregorianCalendar parseDateAdvanced(
+                        @WebParam(name=PARAM_DATETIME) @XmlElement(required=true) String s,
+                        @WebParam(name=PARAM_FORMAT) @XmlElement(required=true) String format,
+                        @WebParam(name=PARAM_TIMEZONE) String timezone) throws XServicesFault;
+        /**
+         * Calculate elapsed time between two dates.
+         * @param fromCal First date.
+         * @param toCal Second date.
+         * @return Elapsed time in milliseconds
+         * @throws XServicesFault
+         */
+        @WebMethod(operationName=OPERATION_DATETIMEDIFF)
+        public abstract BigInteger dateTimeDiff(
+                        @WebParam(name="fromDateTime") @XmlElement(required=true) Date fromCal,
+                        @WebParam(name="toDateTime") @XmlElement(required=true) Date toCal) throws XServicesFault;
+        /**
+         * Fully elapsed units between two dates.
+         * 4:15:10-4:15:55 in minutes = 0 and in seconds = 45
+         *
+         * @param fromCal
+         * @param toCal
+         * @param unit
+         * @return Date/time difference in unit
+         * @throws XServicesFault
+         */
+        @WebMethod(operationName=OPERATION_DATETIMEDIFF2)
+        @WSDLDocumentation(value="Get elapsed time between to dates.")
+        public abstract BigInteger dateTimeDiff2(
+                        @WebParam(name="fromDateTime") @XmlElement(required=true) Date fromCal,
+                        @WebParam(name="toDateTime") @XmlElement(required=true) Date toCal,
+                        @WebParam(name=PARAM_UNIT) DateTimeUnits unit) throws XServicesFault;
+        /**
+         * Add or subtract a time span from a date.
+         *
+         * @param cal The initial date.
+         * @param value The amount to add.
+         * @param unit The unit the amount is defined in.
+         * @return New date and time.
+         * @throws XServicesFault
+         *
+         */
+        @WebMethod(operationName=OPERATION_DATEADD)
+        @WSDLDocumentation(value="Add or substract a time span from a date.")
+        public abstract GregorianCalendar dateAdd(
+                        @WebParam(name=PARAM_DATETIME) @XmlElement(required=true) GregorianCalendar cal,
+                        @WebParam(name="value") @XmlElement(required=true) BigInteger value,
+                        @WebParam(name=PARAM_UNIT) @XmlElement(required=true) DateTimeUnits unit) throws XServicesFault;
+}
 Property changes:
 Added: svn:mime-type
 +text/plain
 \ No newline at end of property

 /xservices/trunk/src/java/net/brutex/xservices/ws/ExecuteService.java
 ,0 → 1,145
+/*
+ *   Copyright 2011 Brian Rosenberger (Brutex Network)
+ *
+ *   Licensed 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 net.brutex.xservices.ws;
+import javax.jws.WebMethod;
+import javax.jws.WebParam;
+import javax.jws.WebService;
+import javax.xml.bind.annotation.XmlElement;
+import net.brutex.xservices.types.HostConnection;
+import net.brutex.xservices.types.ReturnCode;
+import net.brutex.xservices.util.BrutexNamespaces;
+/**
+ * Task execution web service
+ *
+ * @author Brian Rosenberger
+ * @since 0.1.0
+ *
+ */
+@WebService(targetNamespace = BrutexNamespaces.WS_XSERVICES)
+public interface ExecuteService {
+        /**
+         * @param cmd
+         * @param args
+         * @param timeout
+         * @return
+         */
+        @WebMethod(operationName = "runCommand")
+        public abstract ReturnCode runCommand(
+                        @WebParam(name = "executable") String cmd,
+                        @WebParam(name = "argline") String args,
+                        @WebParam(name = "timeout") long timeout);
+        /**
+         * @param cmd
+         * @param args
+         * @param timeout
+         * @return
+         */
+        @WebMethod(operationName = "runCommandWithArgs")
+        public abstract ReturnCode runCommandWithArgs(
+                        @WebParam(name = "executable") String cmd,
+                        @WebParam(name = "arg") String[] args,
+                        @WebParam(name = "timeout") long timeout);
+        /**
+         * @param cmd
+         * @param args
+         * @return
+         */
+        @WebMethod(operationName = "runCommandAsync")
+        public abstract ReturnCode runCommandAsync(
+                        @WebParam(name = "executable") String cmd,
+                        @WebParam(name = "argline") String args);
+        /**
+         * @param cmd
+         * @param args
+         * @return
+         */
+        @WebMethod(operationName = "runCommandAsyncWithArgs")
+        public abstract ReturnCode runCommandAsyncWithArgs(
+                        @WebParam(name = "executable") String cmd,
+                        @WebParam(name = "arg") String[] args);
+        /**
+         * @param host
+         * @param cmd
+         * @param timeout
+         * @return
+         */
+        @WebMethod(operationName = "runCommandWithSSH")
+        public abstract ReturnCode runCommandWithSSH(
+                        @WebParam(name = "host") HostConnection host,
+                        @WebParam(name = "command") String cmd,
+                        @WebParam(name = "timeout") long timeout);
+        /**
+         * @param host
+         * @param keyfile
+         * @param cmd
+         * @param timeout
+         * @return
+         */
+        @WebMethod(operationName = "runCommandWithSSHKeyAuth")
+        public abstract ReturnCode runCommandWithSSHKeyAuth(
+                        @WebParam(name = "host") HostConnection host,
+                        @WebParam(name = "keyfile") String keyfile,
+                        @WebParam(name = "command") String cmd,
+                        @WebParam(name = "timeout") long timeout);
+        /**
+         * @param host
+         * @param cmd
+         * @param timeout
+         * @return
+         */
+        @WebMethod(operationName = "rExec")
+        public abstract ReturnCode rExec(
+                        @WebParam(name = "host") HostConnection host,
+                        @WebParam(name = "command") String cmd,
+                        @WebParam(name = "timeout") long timeout);
+        /**
+         * @param host
+         * @param prompt
+         * @param cmd
+         * @param expect
+         * @param timeout
+         * @return
+         */
+        @WebMethod(operationName = "telnet")
+        public abstract ReturnCode runTelnet(
+                        @WebParam(name = "host") HostConnection host,
+                        @WebParam(name = "prompt") String prompt,
+                        @WebParam(name = "command") String cmd,
+                        @WebParam(name = "expect") String expect,
+                        @WebParam(name = "timeout") long timeout);
+        /**
+         * @param script
+         * @throws XServicesFault
+         */
+        @WebMethod(operationName = "runJavaScript")
+        public abstract void runJScript(
+                        @WebParam(name = "script") @XmlElement(required=true) String script) throws XServicesFault;
+}

Subversion Repositories XServices

Compare Revisions

Regard whitespace Rev HEAD → Rev 177