adminclienttask.java

Java有关XML编程需要用到axis 的源代码 把里面bin下的包导入相应的Java工程 进行使用

/*
 * Copyright 2002,2004 The Apache Software Foundation.
 * 
 * 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 org.apache.axis.tools.ant.axis;

import org.apache.axis.AxisFault;
import org.apache.axis.client.AdminClient;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.DirectoryScanner;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.taskdefs.Java;
import org.apache.tools.ant.taskdefs.MatchingTask;
import org.apache.tools.ant.types.Path;
import org.apache.tools.ant.types.Reference;

import javax.xml.rpc.ServiceException;
import java.io.File;
import java.util.Iterator;
import java.util.LinkedList;

/**
 * Task to administer a local or remote Axis server. Remember, for remote admin,
 * the server has to be accept remote management calls.
 *
 * @ant.task category="axis" name="axis-admin"
 */
public class AdminClientTask extends MatchingTask {

    /**
     * flag to control action on execution trouble
     */
    private boolean failOnError = true;
    private String hostname;
    private int port = 0;
    private String servletPath;
    private File srcDir = null;
    private File xmlFile;
    private String transportChain;
    private String username;
    private String password;
    private String fileProtocol;
    private String action = "";
    private String url;
    private boolean debug;
    private String newPassword;
    private LinkedList argslist;
    private boolean fork = false;
    private Path classpath = null;

    /**
     * set a debug flag
     *
     * @param debug
     */
    public void setDebug(boolean debug) {
        this.debug = debug;
    }

    /**
     * set a new password; only valid if action=passwd
     *
     * @param newPassword
     */
    public void setNewPassword(String newPassword) {
        this.newPassword = newPassword;
    }

    /**
     * full url to the admin endpoint
     *
     * @param url
     */
    public void setUrl(String url) {
        this.url = url;
    }

    /**
     * specifies that a simple file protocol be used
     *
     * @param fileProtocol
     */
    public void setFileProtocol(String fileProtocol) {
        this.fileProtocol = fileProtocol;
    }

    /**
     * name the host to admin
     *
     * @param hostname
     */
    public void setHostname(String hostname) {
        this.hostname = hostname;
    }

    /**
     * the admin password
     *
     * @param password
     */
    public void setPassword(String password) {
        this.password = password;
    }

    /**
     * the port to connect to
     *
     * @param port
     */
    public void setPort(int port) {
        this.port = port;
    }

    /**
     * the path to the AxisAdmin servlet
     *
     * @param servletPath
     */
    public void setServletPath(String servletPath) {
        this.servletPath = servletPath;
    }

    /**
     * Set the source dir to find the source text files.
     */
    public void setSrcdir(File srcDir) {
        this.srcDir = srcDir;
    }

    /**
     * the name of the XML file containing deployment information
     *
     * @param xmlFile
     */
    public void setXmlFile(File xmlFile) {
        this.xmlFile = xmlFile;
    }

    /**
     * set the transport chain to use
     *
     * @param transportChain
     */
    public void setTransportChain(String transportChain) {
        this.transportChain = transportChain;
    }

    /**
     * username to log in as
     *
     * @param username
     */
    public void setUsername(String username) {
        this.username = username;
    }

    /**
     * Whether or not the build should halt if this task fails.
     * Defaults to <code>true</code>.
     */
    public void setFailOnError(boolean fail) {
        failOnError = fail;
    }

    /**
     * If true, forks the ant invocation.
     *
     * @param f "true|false|on|off|yes|no"
     */
    public void setFork(boolean f) {
        fork = f;
    }

    /**
     * validation code
     *
     * @throws org.apache.tools.ant.BuildException
     *          if validation failed
     */
    protected void validate()
            throws BuildException {
        if (srcDir != null) {
            if (!srcDir.exists()) {
                throw new BuildException("srcdir does not exist!");
            }
            if (!srcDir.isDirectory()) {
                throw new BuildException("srcdir is not a directory!");
            }
        }
    }

    /**
     * trace out parameters
     *
     * @param logLevel to log at
     * @see org.apache.tools.ant.Project#log
     */
    public void traceParams(int logLevel) {
        log("Running axis-admin with parameters:", logLevel);
        log("  action:" + action, logLevel);
        log("  url:" + url, logLevel);
        log("  hostname:" + hostname, logLevel);
        log("  port:" + port, logLevel);
        log("  servletPath:" + servletPath, logLevel);
        log("  fileProtocol:" + fileProtocol, logLevel);
        log("  username:" + username, logLevel);
        log("  password:" + password, logLevel);
        log("  transportChain:" + transportChain, logLevel);
        log("  debug:" + debug, logLevel);
    }

    /**
     * <p>Processes a set of administration commands.</p>
     * <p>The following commands are available:</p>
     * <ul>
     * <li><code>-l<i>url</i></code> sets the AxisServlet URL</li>
     * <li><code>-h<i>hostName</i></code> sets the AxisServlet host</li>
     * <li><code>-p<i>portNumber</i></code> sets the AxisServlet port</li>
     * <li><code>-s<i>servletPath</i></code> sets the path to the
     * AxisServlet</li>
     * <li><code>-f<i>fileName</i></code> specifies that a simple file
     * protocol should be used</li>
     * <li><code>-u<i>username</i></code> sets the username</li>
     * <li><code>-w<i>password</i></code> sets the password</li>
     * <li><code>-d</code> sets the debug flag (for instance, -ddd would
     * set it to 3)</li>
     * <li><code>-t<i>name</i></code> sets the transport chain touse</li>
     * <li><code>list</code> will list the currently deployed services</li>
     * <li><code>quit</code> will quit (???)</li>
     * <li><code>passwd <i>value</i></code> changes the admin password</li>
     * <li><code><i>xmlConfigFile</i></code> deploys or undeploys
     * Axis components and web services</li>
     * </ul>
     * <p>If <code>-l</code> or <code>-h -p -s</code> are not set, the
     * AdminClient will invoke
     * <code>http://localhost:8080/axis/servlet/AxisServlet</code>.</p>
     * <p/>
     * outputs XML result or null in case of failure. In the case of multiple
     * commands, the XML results will be concatenated, separated by \n
     *
     * @throws BuildException something went wrong
     */
    public void execute() throws BuildException {
        traceParams(Project.MSG_VERBOSE);
        validate();
        argslist = new LinkedList();

        //build an array of args
        addArgs("-l", url, url != null);
        addArgs("-h", hostname, hostname != null);
        addArgs("-p", Integer.toString(port), port != 0);
        addArgs("-s", servletPath, servletPath != null);
        addArgs("-f", fileProtocol, fileProtocol != null);
        addArgs("-u", username, username != null);
        addArgs("-w", password, password != null);
        addArgs("-t", transportChain, transportChain != null);
        addArg("-d", debug);
        //action
        addArg(action, action != null);
        //action extras
        if ("passwd".equals(action)) {
            if (newPassword == null) {
                throw new BuildException("No newpassword set for passwd");
            }
            addArg(newPassword);
        } else {
            if (newPassword != null) {
                throw new BuildException(
                        "newpassword is only used when action=passwd");
            }
        }

        //final param is the xml file(s)
        if (xmlFile != null) {
            if (!xmlFile.exists()) {
                throw new BuildException("File " + xmlFile + " no found");
            }
            addArg(xmlFile.toString());
        }
        if (srcDir != null) {
            DirectoryScanner ds = super.getDirectoryScanner(srcDir);
            String[] files = ds.getIncludedFiles();
            for (int i = 0; i < files.length; i++) {
                File srcFile = new File(srcDir, files[i]);
                if (!srcFile.exists()) {
                    throw new BuildException("File " + srcFile + " no found");
                }
                addArg(srcFile.getAbsolutePath());
            }
        }
        
        //turn the list into an array
        int counter = 0;
        String[] args = new String[argslist.size()];
        Iterator it = argslist.iterator();
        while (it.hasNext()) {
            String arg = (String) it.next();
            args[counter] = arg;
            counter++;
        }
        if (fork) {
            executeInForkedVM(args);
        } else {
            executeInCurrentVM(args);
        }
    }

    private void executeInForkedVM(String[] args) {
        try {
            // Create an instance of the compiler, redirecting output to
            // the project log
            Java java = (Java) (getProject().createTask("java"));
            getProject().log("using classpath: " + classpath,
                    Project.MSG_DEBUG);
            java.setClasspath(classpath);
            java.setClassname("org.apache.axis.client.AdminClient");
            for (int i = 0; i < args.length; i++) {
                java.createArg().setValue(args[i]);
            }
            java.setFailonerror(failOnError);
            //we are forking here to be sure that if AdminClient calls
            //System.exit() it doesn't halt the build
            java.setFork(true);
            java.setTaskName("AdminClient");
            java.execute();
        } catch (BuildException e) {
            //rethrow these
            throw e;
        } catch (Exception e) {
            throw new BuildException("Exception in " + getTaskName(), e);
        }
    }

    private void executeInCurrentVM(String[] args) {
        //now create a client and invoke it
        AdminClient admin = null;
        try {
            admin = new AdminClient(true);
        } catch (ServiceException e) {
            throw new BuildException("failed to start the axis engine", e);
        }
        String result = null;
        try {
            result = admin.process(args);
            if (result != null) {
                log(result);
            } else {
                logOrThrow(getTaskName() + " got a null response");
            }
        } catch (AxisFault fault) {
            log(fault.dumpToString(), Project.MSG_ERR);
            traceParams(Project.MSG_ERR);
            logOrThrow(getTaskName()
                    + " failed with  "
                    + fault.getFaultCode().toString()
                    + " " + fault.getFaultString());
        } catch (BuildException e) {
            //rethrow these
            throw e;
        } catch (Exception e) {
            throw new BuildException("Exception in " + getTaskName(), e);
        }
    }

    private void logOrThrow(String text) throws BuildException {
        if (failOnError) {
            throw new BuildException(text);
        } else {
            log(text, Project.MSG_ERR);
        }
    }

    /**
     * add one arg
     *
     * @param argument
     */
    protected void addArg(String argument) {
        argslist.add(argument);
    }

    /**
     * add one arg
     *
     * @param argument
     */
    protected void addArg(String argument, boolean test) {
        if (test) {
            argslist.add(argument);
        }
    }

    /**
     * add an arg pair
     *
     * @param argument
     * @param param
     */
    protected void addArgs(String argument, String param) {
        addArg(argument);
        addArg(param);
    }

    /**
     * add an arg pair if the test is true
     *
     * @param argument first arg
     * @param param    param to accompany
     * @param test     test to trigger argument add
     */
    protected void addArgs(String argument, String param, boolean test) {
        if (test) {
            addArg(argument);
            addArg(param);
        }
    }

    /**
     * Set the optional classpath 
     *
     * @param classpath the classpath to use when loading class
     */
    public void setClasspath(Path classpath) {
        createClasspath().append(classpath);
    }

    /**
     * Set the optional classpath 
     *
     * @return a path instance to be configured by the Ant core.
     */
    public Path createClasspath() {
        if (classpath == null) {
            classpath = new Path(getProject());
        }
        return classpath.createPath();
    }

    /**
     * Set the reference to an optional classpath 
     *
     * @param r the id of the Ant path instance to act as the classpath
     */
    public void setClasspathRef(Reference r) {
        createClasspath().setRefid(r);
    }
}