From d965e9aab6b83df6b53cd2a8015fb104d099967f Mon Sep 17 00:00:00 2001 From: jprocter Date: Sat, 15 Jan 2005 15:14:42 +0000 Subject: [PATCH] Jemboss(emboss 2.9.0) classes to provide client functionality to Jalview. --- src/ext/jemboss/JembossJarUtil.java | 167 +++ src/ext/jemboss/JembossParams.java | 1295 ++++++++++++++++++++++++ src/ext/jemboss/soap/JembossRun.java | 142 +++ src/ext/jemboss/soap/JembossSoapException.java | 46 + src/ext/jemboss/soap/MakeFileSafe.java | 83 ++ src/ext/jemboss/soap/PrivateRequest.java | 239 +++++ src/ext/jemboss/soap/PublicRequest.java | 186 ++++ 7 files changed, 2158 insertions(+) create mode 100755 src/ext/jemboss/JembossJarUtil.java create mode 100755 src/ext/jemboss/JembossParams.java create mode 100755 src/ext/jemboss/soap/JembossRun.java create mode 100755 src/ext/jemboss/soap/JembossSoapException.java create mode 100755 src/ext/jemboss/soap/MakeFileSafe.java create mode 100755 src/ext/jemboss/soap/PrivateRequest.java create mode 100755 src/ext/jemboss/soap/PublicRequest.java diff --git a/src/ext/jemboss/JembossJarUtil.java b/src/ext/jemboss/JembossJarUtil.java new file mode 100755 index 0000000..ad10cd2 --- /dev/null +++ b/src/ext/jemboss/JembossJarUtil.java @@ -0,0 +1,167 @@ +/*************************************************************** +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* as published by the Free Software Foundation; either version 2 +* of the License, or (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +* +* @author: Copyright (C) Tim Carver +* +***************************************************************/ + +package ext.jemboss; + +import java.util.*; +import java.util.zip.*; +import java.io.*; + + +/** +* +* Unpacks a Jar file into a Hashtable +* +*/ +public class JembossJarUtil +{ + + /** Hashtable containing the unpacked contents of the jar file */ + private Hashtable jarStore = new Hashtable(); + + /** + * + * Given the path to a jar file unpack to a hashtable + * @param jarFile path to jar file to unpack + * @throws Exception if it is not possible to read jar file + * + */ + public JembossJarUtil(String jarFile) throws Exception + { + + try + { + // extracts just sizes only + ClassLoader cl = this.getClass().getClassLoader(); + ZipInputStream zis= new ZipInputStream( + cl.getResourceAsStream(jarFile)); + ZipEntry ze=null; + Hashtable htSizes = new Hashtable(); + + while((ze=zis.getNextEntry())!=null) + { + int ret=0; + int cnt=0; + int rb = 0; + while(ret != -1) + { + byte[] b1 = new byte[1]; + ret=zis.read(b1,rb,1); + cnt++; + } + htSizes.put(ze.getName(),new Integer(cnt)); + } + zis.close(); + + // extract resources and put them into the hashtable + zis = new ZipInputStream(cl.getResourceAsStream(jarFile)); + ze=null; + while ((ze=zis.getNextEntry())!=null) + { + if(ze.isDirectory()) + continue; + + int size=(int)ze.getSize(); // -1 means unknown size + if(size==-1) + size=((Integer)htSizes.get(ze.getName())).intValue(); + + byte[] b=new byte[(int)size]; + int rb=0; + int chunk=0; + while (((int)size - rb) > 0) + { + chunk=zis.read(b,rb,(int)size - rb); + if(chunk==-1) + break; + rb+=chunk; + } + + // add to internal resource hashtable + jarStore.put(ze.getName(),b); + +// System.out.println(ze.getName()); + } + zis.close(); + } + catch (Exception e) { throw new Exception();} + +// catch (NullPointerException e) +// { +// System.out.println("JembossJarUtil Error: jarStore"); +// } +// catch (FileNotFoundException e) +// { +// e.printStackTrace(); +// } +// catch (IOException e) +// { +// e.printStackTrace(); +// } + } + + + /** + * + * Return the hashtable + * @return jarStore the hashtable containing the contents + * of the jar + * + */ + public Hashtable getHash() + { + return jarStore; + } + + /** + * + * Return an element of the hashtable + * @param el key of an element in the hashtable + * @return the hashtable containing the contents + * of the jar + * + */ + public Object getElement(String el) + { + return jarStore.get(el); + } + + /** + * + * Write contents of an element in the hashtable + * @param el key of an element in the hashtable + * @param f path of file to write to + * @return true if written file + * + */ + public boolean writeByteFile(String el, String f) + { + try + { + FileOutputStream out = new FileOutputStream(f); + out.write((byte []) jarStore.get(el)); + out.close(); + } + catch(FileNotFoundException fnfe) {return false;} + catch(IOException ioe) {return false;} + + return true; + } + +} diff --git a/src/ext/jemboss/JembossParams.java b/src/ext/jemboss/JembossParams.java new file mode 100755 index 0000000..b9580b5 --- /dev/null +++ b/src/ext/jemboss/JembossParams.java @@ -0,0 +1,1295 @@ +/*************************************************************** +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* as published by the Free Software Foundation; either version 2 +* of the License, or (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +* +* @author: Copyright (C) Tim Carver +* +***************************************************************/ + +package ext.jemboss; + +import java.util.*; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.net.InetAddress; + + +/** +* +* Contains all property information about the client +* and the server. +* +*/ +public class JembossParams +{ + +/** denotes a server is OK */ + static public final int SERVER_OK = 0; +/** denotes a server is giving errors */ + static public final int SERVER_ERR = 1; +/** denotes a server is not responding */ + static public final int SERVER_DOWN = 2; + + // these are the things that could be set + private boolean useHTTPSProxy = false; + private String useHTTPSProxyName = "useHTTPSProxy"; + + private boolean useProxy = false; + private String useProxyName = "proxy.use"; + + private String proxyHost = "wwwcache"; + private String proxyHostName = "proxy.host"; + + private int proxyPortNum = 8080; + private String proxyPortNumName = "proxy.port"; + +//browser proxy + + /** use a separate proxy for browsing the web */ + private boolean useBrowserProxy = false; + /** property name for using separate proxy for browsing the web */ + private String useBrowserProxyName = "browserProxy.use"; + /** browser proxy host */ + private String browserProxyHost = "wwwcache"; + /** property name for browser proxy host */ + private String browserProxyHostName = "browserProxy.host"; + /** browser proxy port */ + private int browserProxyPort = 8080; + /** property name for browser proxy port */ + private String browserProxyPortName = "browserProxy.port"; + + private boolean useTFM; + private String useTFMName = "tfm.use"; + + /** use proxy authentication */ + private boolean useProxyAuth = false; + /** property name for using proxy authentication */ + private String useProxyAuthName = "proxy.auth"; + + private String proxyAuthUser = ""; + private String proxyAuthUserName = "proxy.user"; + + private String proxyAuthPasswd = ""; + private String proxyAuthPasswdName = "proxy.passwd"; + + private boolean proxyOverride = false; + private String proxyOverrideName = "proxy.override"; + + /** use unix authentication to run applications on the server */ + private boolean useAuth = false; + /** property name for using unix authentication */ + private String useAuthName = "user.auth"; + + /** public services URL */ + private String publicSoapURL = + "http://anaplog.compbio.dundee.ac.uk:8080/axis/services"; + /** property name for public services URL */ + private String publicSoapURLName = "server.public"; + + /** private services URL */ + private String privateSoapURL = + "http://anaplog.compbio.dundee.ac.uk:8080/axis/services"; + /** property name for private services URL */ + private String privateSoapURLName = "server.private"; + + /** service name */ + private String soapService = "JembossServer"; + /** property name for service name */ + private String soapServiceName = "VAMSAS Services"; + + /** private service name */ + private String privateSoapService = "JembossServer"; + /** property name for private service name */ + private String privateSoapServiceName = "VAMSAS Services"; + + /** public service name */ + private String publicSoapService = "JembossServer"; + /** property name for public service name */ + private String publicSoapServiceName = "VAMSAS Services"; + + //soap options + private boolean debug = false; + private String debugName = "jemboss.debug"; + + /** batch mode support */ + private boolean hasBatchMode = true; + /** property name for batch mode support */ + private String hasBatchModeName = "jemboss.hasbatchmode"; + /** interactive mode support */ + private boolean hasInteractiveMode = true; + /** property name for interactive mode support */ + private String hasInteractiveModeName = "jemboss.hasinteractivemode"; + /** current mode for running an application */ + private String currentMode = "interactive"; + /** property name for current mode */ + private String currentModeName = "jemboss.mode"; + + // server lists for redundancy + private String serverPublicList = ""; + private String serverPublicListName = "server.publiclist"; + + private String serverPrivateList = ""; + private String serverPrivateListName = "server.privatelist"; + + // we don't remember these perhaps we should for captive systems + private String serviceUserName = "jalview"; + private String serviceUserNameName = "user.name"; + private char[] servicePasswd = null; + /** services password */ + private byte[] servicePasswdByte = null; + + Properties jembossSettings; + + // Internal flags to help in the dynamic evaluation of properties + private boolean useJavaProxy = false; + private String javaProxyPort = ""; + private String javaProxyHost = ""; + private boolean useJavaNoProxy = false; + private String javaNoProxy = ""; + private Vector javaNoProxyEntries; + private int javaProxyPortNum = 8080; + + // structures for server redundancy + private boolean publicServerFailOver = false; + private boolean privateServerFailOver = false; + private Hashtable serverStatusHash; + private Vector publicServers; + private Vector privateServers; + + /** Jemboss java server */ + private static boolean jembossServer = false; + /** property name for Jemboss java server */ + private String jembossServerName = "jemboss.server"; + + /** cygwin */ + private static String cygwin = null; + /** property name for Jemboss java server */ + private String cygwinName = "cygwin"; + + //EMBOSS directories + /** plplot library location */ + private String plplot = "/usr/local/share/EMBOSS/"; + /** property name for plplot library location */ + private String plplotName = "plplot"; + /** emboss data location */ + private String embossData = "/usr/local/share/EMBOSS/data/"; + /** property name for emboss data location */ + private String embossDataName = "embossData"; + /** emboss binary location */ + private String embossBin = "/usr/local/bin/"; + /** property name for emboss binary location */ + private String embossBinName = "embossBin"; + /** emboss path environment variable */ + private String embossPath = "/usr/bin/:/bin"; + /** property name for emboss path environment variable */ + private String embossPathName = "embossPath"; + /** emboss environment */ + private String embossEnvironment = ""; + /** property name for emboss environment */ + private String embossEnvironmentName = "embossEnvironment"; + /** acd file location */ + private String acdDirToParse = "/usr/local/share/EMBOSS/acd/"; + /** property name for acd file location */ + private String acdDirToParseName = "acdDirToParse"; + + //EMBOSS Application pages + /** documentation URL */ + private String embURL = "http://www.uk.embnet.org/Software/EMBOSS/Apps/"; + /** property name for documentation URL */ + private String embossURL = "embossURL"; + + // user properties + /** user home directory */ + private String userHome = System.getProperty("user.home"); + /** property name for user home directory */ + private String userHomeName = "user.home"; + + +/** +* +* Loads and holds the properties +* +*/ + public JembossParams() + { + Properties defaults = new Properties(); + ClassLoader cl = this.getClass().getClassLoader(); + + // initialize data structures + serverStatusHash = new Hashtable(); + publicServers = new Vector(); + privateServers = new Vector(); + + // initialize settings from table above + defaults.put(userHomeName,userHome); + defaults.put(embossURL,embURL); + defaults.put(plplotName,plplot); + defaults.put(embossDataName,embossData); + defaults.put(embossBinName,embossBin); + defaults.put(embossPathName,embossPath); + defaults.put(embossEnvironmentName,embossEnvironment); + defaults.put(acdDirToParseName,acdDirToParse); + + defaults.put(useBrowserProxyName, new Boolean(useBrowserProxy).toString()); + defaults.put(browserProxyHostName,browserProxyHost); + defaults.put(browserProxyPortName,new Integer(browserProxyPort).toString()); + + defaults.put(useTFMName,new Boolean(useTFM).toString()); + + defaults.put(useProxyName, new Boolean(useProxy).toString()); + defaults.put(useHTTPSProxyName, new Boolean(useHTTPSProxy).toString()); + defaults.put(proxyHostName,proxyHost); + defaults.put(proxyPortNumName, new Integer(proxyPortNum).toString()); + defaults.put(useProxyAuthName, new Boolean(useProxyAuth).toString()); + defaults.put(proxyAuthUserName, proxyAuthUser); + defaults.put(proxyAuthPasswdName, proxyAuthPasswd); + defaults.put(proxyOverrideName, new Boolean(proxyOverride).toString()); + defaults.put(useAuthName, new Boolean(useAuth).toString()); + defaults.put(publicSoapURLName, publicSoapURL); + defaults.put(privateSoapURLName, privateSoapURL); + defaults.put(privateSoapServiceName, privateSoapService); + defaults.put(publicSoapServiceName, publicSoapService); + defaults.put(debugName, new Boolean(debug).toString()); + defaults.put(hasBatchModeName, new Boolean(hasBatchMode).toString()); + defaults.put(hasInteractiveModeName, new Boolean(hasInteractiveMode).toString()); + defaults.put(currentModeName, currentMode); + defaults.put(serverPublicListName, serverPublicList); + defaults.put(serverPrivateListName, serverPrivateList); + defaults.put(serviceUserNameName, serviceUserName); + + // load into real settings + jembossSettings = new Properties(defaults); + + // try out of the classpath + try + { + jembossSettings.load(cl.getResourceAsStream("resources/jemboss.properties")); + } + catch (Exception e) + { + if(debug) + System.out.println("Didn't find properties file in classpath."); + } + + // override with local system settings + loadIn(System.getProperty("user.dir")); + + // override with local user settings + loadIn(System.getProperty("user.home")); + + // update our settings + updateSettingsFromProperties(); + + if(System.getProperty("useHTTPSProxy") != null) + if(System.getProperty("useHTTPSProxy").equalsIgnoreCase("true")) + useHTTPSProxy=true; + + // set up for overrides + javaNoProxyEntries = new Vector(); + if(System.getProperty("proxyPort") != null) + { + if(System.getProperty("proxyHost") != null) + { + useJavaProxy = true; + useProxy = useJavaProxy; + useBrowserProxy = useJavaProxy; + + javaProxyPort = System.getProperty("proxyPort"); + javaProxyPortNum = Integer.parseInt(javaProxyPort); + javaProxyHost = System.getProperty("proxyHost"); + + browserProxyHost = javaProxyHost; + browserProxyPort = javaProxyPortNum; + + if(System.getProperty("http.nonProxyHosts") != null) + { + useJavaNoProxy = true; + javaNoProxy = System.getProperty("http.nonProxyHosts"); + StringTokenizer tok = new StringTokenizer(javaNoProxy,"|"); + while (tok.hasMoreTokens()) + { + String toks = tok.nextToken() + "/"; + javaNoProxyEntries.add(toks); + } + } + } + } + + } + + /** + * + * Load a property from the jemboss.property file. + * @param folder location of jemboss.property + * + */ + private void loadIn(String folder) + { + FileInputStream in = null; + try + { + String fs = System.getProperty("file.separator"); + in = new FileInputStream(folder + fs + "jemboss.properties"); + jembossSettings.load(in); + } + catch (java.io.FileNotFoundException e) + { + in = null; + if(debug) + System.out.println("Can't find properties file in"+folder+"."+ + " Using defaults."); + } + catch (java.io.IOException e) + { + if(debug) + System.out.println("Can't read properties file. " + + "Using defaults."); + } + finally + { + if (in != null) + { + try { in.close(); } catch (java.io.IOException e) { } + in = null; + } + } + + } + + /** + * + * Update the property settings for jembossSettings. + * + */ + protected void updateSettingsFromProperties() + { + + try + { + String tmp; + + userHome = jembossSettings.getProperty(userHomeName); + embURL = jembossSettings.getProperty(embossURL); + plplot = jembossSettings.getProperty(plplotName); + embossData = jembossSettings.getProperty(embossDataName); + embossBin = jembossSettings.getProperty(embossBinName); + embossPath = jembossSettings.getProperty(embossPathName); + embossEnvironment = jembossSettings.getProperty(embossEnvironmentName); + acdDirToParse = jembossSettings.getProperty(acdDirToParseName); + tmp = jembossSettings.getProperty(jembossServerName); + jembossServer = new Boolean(tmp).booleanValue(); + + cygwin = jembossSettings.getProperty(cygwinName); + + tmp = jembossSettings.getProperty(useHTTPSProxyName); + useHTTPSProxy = new Boolean(tmp).booleanValue(); + tmp = jembossSettings.getProperty(useProxyName); + useProxy = new Boolean(tmp).booleanValue(); + proxyHost = jembossSettings.getProperty(proxyHostName); + tmp = jembossSettings.getProperty(proxyPortNumName); + proxyPortNum = Integer.parseInt(tmp); + + tmp = jembossSettings.getProperty(useBrowserProxyName); + useBrowserProxy = new Boolean(tmp).booleanValue(); + browserProxyHost = jembossSettings.getProperty(browserProxyHostName); + tmp = jembossSettings.getProperty(browserProxyPortName); + browserProxyPort = Integer.parseInt(tmp); + + tmp = jembossSettings.getProperty(useTFMName); + useTFM = new Boolean(tmp).booleanValue(); + + tmp = jembossSettings.getProperty(useProxyAuthName); + useProxyAuth = new Boolean(tmp).booleanValue(); + proxyAuthUser = jembossSettings.getProperty(proxyAuthUserName); + proxyAuthPasswd = jembossSettings.getProperty(proxyAuthPasswdName); + tmp = jembossSettings.getProperty(proxyOverrideName); + proxyOverride = new Boolean(tmp).booleanValue(); + tmp = jembossSettings.getProperty(useAuthName); + useAuth = new Boolean(tmp).booleanValue(); + publicSoapURL = jembossSettings.getProperty(publicSoapURLName); + privateSoapURL = jembossSettings.getProperty(privateSoapURLName); + soapService = jembossSettings.getProperty(soapServiceName); + privateSoapService = jembossSettings.getProperty(privateSoapServiceName); + publicSoapService = jembossSettings.getProperty(publicSoapServiceName); + tmp = jembossSettings.getProperty(debugName); + debug = new Boolean(tmp).booleanValue(); + tmp = jembossSettings.getProperty(hasBatchModeName); + hasBatchMode = new Boolean(tmp).booleanValue(); + tmp = jembossSettings.getProperty(hasInteractiveModeName); + hasInteractiveMode = new Boolean(tmp).booleanValue(); + currentMode = jembossSettings.getProperty(currentModeName); + serverPublicList = jembossSettings.getProperty(serverPublicListName); + serverPrivateList = jembossSettings.getProperty(serverPrivateListName); +// serviceUserName = jembossSettings.getProperty(serviceUserNameName); + } + catch (Exception e) { } + } + +/** +* +* Initialize the server redundancy data. This is a separate +* method because the server info might not be initialized in +* the constructor, but may be imported later from the command line. +* +*/ + protected void setupServerRedundancy() + { + if (!serverPublicList.equals("")) + { + if(debug) + System.out.println("JembossParams: Redundant public servers\n " + +serverPublicList); + + publicServerFailOver = true; + StringTokenizer tok = new StringTokenizer(serverPublicList,"|"); + while (tok.hasMoreTokens()) + { + String toks = tok.nextToken(); + publicServers.add(toks); + if(debug) + System.out.println(" Entry " + toks); + + serverStatusHash.put(toks, new Integer(SERVER_OK)); + } + } + + if(!serverPrivateList.equals("")) + { + if(debug) + System.out.println("JembossParams: Redundant private servers\n " + +serverPrivateList); + + privateServerFailOver = true; + StringTokenizer tok = new StringTokenizer(serverPrivateList,"|"); + while (tok.hasMoreTokens()) + { + String toks = tok.nextToken(); + privateServers.add(toks); + if(debug) + System.out.println(" Entry " + toks); + + serverStatusHash.put(toks,new Integer(SERVER_OK)); + } + } + } + + +/** +* +* If using a proxy server +* +*/ + public boolean getUseProxy() + { + return useProxy; + } + + +/** +* +* If using an https proxy server +* +*/ + public boolean getUseHTTPSProxy() + { + return useHTTPSProxy; + } + + +/** +* +* If using a proxy server for a given URL +* @param s the URL we wish to connect to +* +*/ + public boolean getUseProxy(String s) + { + if(proxyOverride) + return useProxy; + else + { + if(!useJavaProxy) + return useProxy; + else + { + boolean jp = true; + if (useJavaNoProxy) + { + int ip = javaNoProxyEntries.size(); + for(int j = 0 ; j') + dest.append('_'); + else if(c == '<') + dest.append('_'); + else if(c == ';') + dest.append('_'); + else if(c == '\\') + dest.append('_'); + else + dest.append(c); + + } + safeFileName = dest.toString(); + } + + /** + * + * Get the safe/sanitised file name + * @return sanitised file name + * + */ + public String getSafeFileName() + { + return safeFileName; + } +} diff --git a/src/ext/jemboss/soap/PrivateRequest.java b/src/ext/jemboss/soap/PrivateRequest.java new file mode 100755 index 0000000..582949d --- /dev/null +++ b/src/ext/jemboss/soap/PrivateRequest.java @@ -0,0 +1,239 @@ +/**************************************************************** +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public License +* as published by the Free Software Foundation; either version 2 +* of the License, or (at your option) any later version. +* +* This program is distributed in the hope that it will be useful, +* but WITHOUT ANY WARRANTY; without even the implied warranty of +* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +* GNU General Public License for more details. +* +* You should have received a copy of the GNU General Public License +* along with this program; if not, write to the Free Software +* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +* +* @author: Copyright (C) Tim Carver +* +***************************************************************/ + +package ext.jemboss.soap; + +import java.io.*; +import java.util.*; + +import ext.jemboss.JembossParams; +import javax.swing.JOptionPane; +//AXIS +import org.apache.axis.client.Call; +import org.apache.axis.client.Service; +import javax.xml.namespace.QName; +import org.apache.axis.encoding.XMLType; + +/** +* +* Make a axis call to a private server, using the default service +* +*/ +public class PrivateRequest +{ + + /** results from calling the web service */ + private Hashtable proganswer; + + /** + * + * @param mysettings jemboss properties + * @param method method to call + * @param args arguments + * @throws JembossSoapException if authentication fails + * + */ + public PrivateRequest(JembossParams mysettings, String method, Vector args) + throws JembossSoapException + { + this(mysettings, mysettings.getPrivateSoapService(), method, args); + } + + /** + * + * @param mysettings jemboss properties + * @param service service to call + * @param method method to call + * @throws JembossSoapException If authentication fails + * + */ + public PrivateRequest(JembossParams mysettings, String service, String method) + throws JembossSoapException + { + this(mysettings, service, method, (Vector) null); + } + + /** + * + * @param mysettings jemboss properties + * @param service service to call + * @param method method to call + * @param args arguments + * @throws JembossSoapException if authentication fails + */ + public PrivateRequest(JembossParams mysettings, String service, String method, + Vector args) throws JembossSoapException + { + try + { + String endpoint = mysettings.getPublicSoapURL()+"/"+service; + org.apache.axis.client.Service serv = + new org.apache.axis.client.Service(); + Call call = (Call) serv.createCall(); + QName qn = new QName(service, method); + call.setTargetEndpointAddress( new java.net.URL(endpoint) ); + call.setOperationName(new QName(service, method)); + call.setEncodingStyle(org.apache.axis.Constants.URI_SOAP12_ENC); + + int nargs = 0; + Object params[] = null; + if(args != null) + { + if(mysettings.getUseAuth()) + nargs = args.size()+2; + else + nargs = args.size()+1; + + params = new Object[nargs]; + Enumeration e = args.elements(); + for(int i=0;i