| /xservices/branches/xservices-jre7/src/java/net/brutex/xservices/ws/impl/XmlServiceImpl.java |
|---|
| 0,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/branches/xservices-jre7/src/java/net/brutex/xservices/ws/impl/ExecuteServiceImpl.java |
|---|
| 0,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, |
| 0); |
| } |
| /* |
| * (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/branches/xservices-jre7/src/java/net/brutex/xservices/ws/impl/StringServiceImpl.java |
|---|
| 0,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/branches/xservices-jre7/src/java/net/brutex/xservices/ws/impl/DateServiceImpl.java |
|---|
| 0,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/branches/xservices-jre7/src/java/net/brutex/xservices/ws/impl/FileServiceImpl.java |
|---|
| 0,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/branches/xservices-jre7/src/java/net/brutex/xservices/ws/impl/messages.properties |
|---|
| 0,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/branches/xservices-jre7/src/java/net/brutex/xservices/ws/impl/ArchiveServiceImpl.java |
|---|
| 0,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/branches/xservices-jre7/src/java/net/brutex/xservices/ws/impl/StorageServiceImpl.java |
|---|
| 0,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/branches/xservices-jre7/src/java/net/brutex/xservices/ws/impl/Messages.java |
|---|
| 0,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/branches/xservices-jre7/src/java/net/brutex/xservices/ws/impl/MiscServiceImpl.java |
|---|
| 0,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/branches/xservices-jre7/src/java/net/brutex/xservices/ws/impl/JobServiceImpl.java |
|---|
| 0,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/branches/xservices-jre7/src/java/net/brutex/xservices/ws/impl/MailServiceImpl.java |
|---|
| 0,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 |