geronimo-scm mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jlaskow...@apache.org
Subject svn commit: r393787 [7/22] - in /geronimo/trunk/applications: ./ console/ console/console-core/ console/console-core/src/ console/console-core/src/java/ console/console-core/src/java/org/ console/console-core/src/java/org/apache/ console/console-core/s...
Date Thu, 13 Apr 2006 11:36:26 GMT
Added: geronimo/trunk/applications/console/console-standard/src/java/org/apache/geronimo/console/databasemanager/wizard/DatabasePoolPortlet.java
URL: http://svn.apache.org/viewcvs/geronimo/trunk/applications/console/console-standard/src/java/org/apache/geronimo/console/databasemanager/wizard/DatabasePoolPortlet.java?rev=393787&view=auto
==============================================================================
--- geronimo/trunk/applications/console/console-standard/src/java/org/apache/geronimo/console/databasemanager/wizard/DatabasePoolPortlet.java (added)
+++ geronimo/trunk/applications/console/console-standard/src/java/org/apache/geronimo/console/databasemanager/wizard/DatabasePoolPortlet.java Thu Apr 13 04:34:08 2006
@@ -0,0 +1,1490 @@
+/**
+ *
+ * Copyright 2003-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.geronimo.console.databasemanager.wizard;
+
+import java.io.IOException;
+import java.io.Serializable;
+import java.io.PrintWriter;
+import java.io.StringWriter;
+import java.io.File;
+import java.io.BufferedOutputStream;
+import java.io.FileOutputStream;
+import java.io.StringReader;
+import java.io.ByteArrayOutputStream;
+import java.io.FileReader;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Properties;
+import java.net.URISyntaxException;
+import java.net.URI;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.net.MalformedURLException;
+import java.sql.Driver;
+import java.sql.SQLException;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import javax.portlet.PortletRequestDispatcher;
+import javax.portlet.PortletConfig;
+import javax.portlet.PortletException;
+import javax.portlet.ActionRequest;
+import javax.portlet.ActionResponse;
+import javax.portlet.RenderRequest;
+import javax.portlet.RenderResponse;
+import javax.portlet.WindowState;
+import javax.portlet.PortletRequest;
+import javax.portlet.PortletSession;
+import javax.management.ObjectName;
+import javax.management.MalformedObjectNameException;
+import javax.enterprise.deploy.spi.DeploymentManager;
+import javax.enterprise.deploy.spi.DeploymentConfiguration;
+import javax.enterprise.deploy.spi.Target;
+import javax.enterprise.deploy.spi.TargetModuleID;
+import javax.enterprise.deploy.spi.status.ProgressObject;
+import javax.enterprise.deploy.model.DDBeanRoot;
+import javax.enterprise.deploy.model.DDBean;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.DocumentBuilder;
+import org.apache.geronimo.console.BasePortlet;
+import org.apache.geronimo.console.GeronimoVersion;
+import org.apache.geronimo.console.util.PortletManager;
+import org.apache.geronimo.management.geronimo.JCAManagedConnectionFactory;
+import org.apache.geronimo.management.geronimo.ResourceAdapterModule;
+import org.apache.geronimo.j2ee.j2eeobjectnames.NameFactory;
+import org.apache.geronimo.kernel.repository.ListableRepository;
+import org.apache.geronimo.kernel.repository.Repository;
+import org.apache.geronimo.kernel.repository.WriteableRepository;
+import org.apache.geronimo.kernel.repository.FileWriteMonitor;
+import org.apache.geronimo.kernel.management.State;
+import org.apache.geronimo.kernel.proxy.GeronimoManagedBean;
+import org.apache.geronimo.deployment.tools.loader.ConnectorDeployable;
+import org.apache.geronimo.connector.deployment.jsr88.Connector15DCBRoot;
+import org.apache.geronimo.connector.deployment.jsr88.ConnectorDCB;
+import org.apache.geronimo.connector.deployment.jsr88.Dependency;
+import org.apache.geronimo.connector.deployment.jsr88.ResourceAdapter;
+import org.apache.geronimo.connector.deployment.jsr88.ConnectionDefinition;
+import org.apache.geronimo.connector.deployment.jsr88.ConnectionDefinitionInstance;
+import org.apache.geronimo.connector.deployment.jsr88.ConfigPropertySetting;
+import org.apache.geronimo.connector.deployment.jsr88.ConnectionManager;
+import org.apache.geronimo.connector.deployment.jsr88.SinglePool;
+import org.apache.geronimo.connector.outbound.PoolingAttributes;
+import org.apache.geronimo.converter.DatabaseConversionStatus;
+import org.apache.geronimo.converter.JDBCPool;
+import org.apache.geronimo.converter.bea.WebLogic81DatabaseConverter;
+import org.apache.geronimo.converter.jboss.JBoss4DatabaseConverter;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.apache.commons.fileupload.portlet.PortletFileUpload;
+import org.apache.commons.fileupload.disk.DiskFileItemFactory;
+import org.apache.commons.fileupload.FileItem;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.NodeList;
+import org.w3c.dom.Node;
+import org.xml.sax.InputSource;
+
+/**
+ * A portlet that lets you configure and deploy JDBC connection pools.
+ *
+ * @version $Rev$ $Date$
+ */
+public class DatabasePoolPortlet extends BasePortlet {
+    private final static Log log = LogFactory.getLog(DatabasePoolPortlet.class);
+    private final static String[] SKIP_ENTRIES_WITH = new String[]{"geronimo", "tomcat", "tranql", "commons", "directory", "activemq"};
+    private final static String DRIVER_SESSION_KEY = "org.apache.geronimo.console.dbpool.Drivers";
+    private final static String CONFIG_SESSION_KEY = "org.apache.geronimo.console.dbpool.ConfigParam";
+    private final static String DRIVER_INFO_URL    = "http://people.apache.org/~ammulder/driver-downloads.properties";
+    private static final String LIST_VIEW            = "/WEB-INF/view/dbwizard/list.jsp";
+    private static final String EDIT_VIEW            = "/WEB-INF/view/dbwizard/edit.jsp";
+    private static final String SELECT_RDBMS_VIEW    = "/WEB-INF/view/dbwizard/selectDatabase.jsp";
+    private static final String BASIC_PARAMS_VIEW    = "/WEB-INF/view/dbwizard/basicParams.jsp";
+    private static final String CONFIRM_URL_VIEW     = "/WEB-INF/view/dbwizard/confirmURL.jsp";
+    private static final String TEST_CONNECTION_VIEW = "/WEB-INF/view/dbwizard/testConnection.jsp";
+    private static final String DOWNLOAD_VIEW        = "/WEB-INF/view/dbwizard/selectDownload.jsp";
+    private static final String SHOW_PLAN_VIEW       = "/WEB-INF/view/dbwizard/showPlan.jsp";
+    private static final String IMPORT_UPLOAD_VIEW   = "/WEB-INF/view/dbwizard/importUpload.jsp";
+    private static final String IMPORT_STATUS_VIEW   = "/WEB-INF/view/dbwizard/importStatus.jsp";
+    private static final String USAGE_VIEW           = "/WEB-INF/view/dbwizard/usage.jsp";
+    private static final String LIST_MODE            = "list";
+    private static final String EDIT_MODE            = "edit";
+    private static final String SELECT_RDBMS_MODE    = "rdbms";
+    private static final String BASIC_PARAMS_MODE    = "params";
+    private static final String CONFIRM_URL_MODE     = "url";
+    private static final String TEST_CONNECTION_MODE = "test";
+    private static final String SHOW_PLAN_MODE       = "plan";
+    private static final String DOWNLOAD_MODE        = "download";
+    private static final String EDIT_EXISTING_MODE   = "editExisting";
+    private static final String SAVE_MODE            = "save";
+    private static final String IMPORT_START_MODE    = "startImport";
+    private static final String IMPORT_UPLOAD_MODE   = "importUpload";
+    private static final String IMPORT_STATUS_MODE   = "importStatus";
+    private static final String IMPORT_COMPLETE_MODE = "importComplete";
+    private static final String WEBLOGIC_IMPORT_MODE = "weblogicImport";
+    private static final String USAGE_MODE           = "usage";
+    private static final String IMPORT_EDIT_MODE   = "importEdit";
+    private static final String MODE_KEY = "mode";
+
+    private PortletRequestDispatcher listView;
+    private PortletRequestDispatcher editView;
+    private PortletRequestDispatcher selectRDBMSView;
+    private PortletRequestDispatcher basicParamsView;
+    private PortletRequestDispatcher confirmURLView;
+    private PortletRequestDispatcher testConnectionView;
+    private PortletRequestDispatcher downloadView;
+    private PortletRequestDispatcher planView;
+    private PortletRequestDispatcher importUploadView;
+    private PortletRequestDispatcher importStatusView;
+    private PortletRequestDispatcher usageView;
+
+    public void init(PortletConfig portletConfig) throws PortletException {
+        super.init(portletConfig);
+        listView = portletConfig.getPortletContext().getRequestDispatcher(LIST_VIEW);
+        editView = portletConfig.getPortletContext().getRequestDispatcher(EDIT_VIEW);
+        selectRDBMSView = portletConfig.getPortletContext().getRequestDispatcher(SELECT_RDBMS_VIEW);
+        basicParamsView = portletConfig.getPortletContext().getRequestDispatcher(BASIC_PARAMS_VIEW);
+        confirmURLView = portletConfig.getPortletContext().getRequestDispatcher(CONFIRM_URL_VIEW);
+        testConnectionView = portletConfig.getPortletContext().getRequestDispatcher(TEST_CONNECTION_VIEW);
+        downloadView = portletConfig.getPortletContext().getRequestDispatcher(DOWNLOAD_VIEW);
+        planView = portletConfig.getPortletContext().getRequestDispatcher(SHOW_PLAN_VIEW);
+        importUploadView = portletConfig.getPortletContext().getRequestDispatcher(IMPORT_UPLOAD_VIEW);
+        importStatusView = portletConfig.getPortletContext().getRequestDispatcher(IMPORT_STATUS_VIEW);
+        usageView = portletConfig.getPortletContext().getRequestDispatcher(USAGE_VIEW);
+    }
+
+    public void destroy() {
+        listView = null;
+        editView = null;
+        selectRDBMSView = null;
+        basicParamsView = null;
+        confirmURLView = null;
+        testConnectionView = null;
+        downloadView = null;
+        planView = null;
+        importUploadView = null;
+        importStatusView = null;
+        usageView = null;
+        super.destroy();
+    }
+
+    public DriverDownloader.DriverInfo[] getDriverInfo(PortletRequest request) {
+        PortletSession session = request.getPortletSession(true);
+        DriverDownloader.DriverInfo[] results = (DriverDownloader.DriverInfo[]) session.getAttribute(DRIVER_SESSION_KEY, PortletSession.APPLICATION_SCOPE);
+        if(results == null) {
+            DriverDownloader downloader = new DriverDownloader();
+            try {
+                results = downloader.loadDriverInfo(new URL(DRIVER_INFO_URL));
+                session.setAttribute(DRIVER_SESSION_KEY, results, PortletSession.APPLICATION_SCOPE);
+            } catch (MalformedURLException e) {
+                log.error("Unable to download driver data", e);
+                results = new DriverDownloader.DriverInfo[0];
+            }
+        }
+        return results;
+    }
+
+    /**
+     * Loads data about a resource adapter.  Depending on what we already have, may load
+     * the name and description, but always loads the config property descriptions.
+     * @param request            Pass it or die
+     * @param rarPath            If we're creating a new RA, the path to identify it
+     * @param displayName        If we're editing an existing RA, its name
+     * @param adapterObjectName  If we're editing an existing RA, its ObjectName
+     */
+    public ResourceAdapterParams getRARConfiguration(PortletRequest request, String rarPath, String displayName, String adapterObjectName) {
+        PortletSession session = request.getPortletSession(true);
+        if(rarPath != null && !rarPath.equals("")) {
+            ResourceAdapterParams results = (ResourceAdapterParams) session.getAttribute(CONFIG_SESSION_KEY+"-"+rarPath, PortletSession.APPLICATION_SCOPE);
+            if(results == null) {
+                results = loadConfigPropertiesByPath(request, rarPath);
+                session.setAttribute(CONFIG_SESSION_KEY+"-"+rarPath, results, PortletSession.APPLICATION_SCOPE);
+                session.setAttribute(CONFIG_SESSION_KEY+"-"+results.displayName, results, PortletSession.APPLICATION_SCOPE);
+            }
+            return results;
+        } else if(displayName != null && !displayName.equals("") && adapterObjectName != null && !adapterObjectName.equals("")) {
+            ResourceAdapterParams results = (ResourceAdapterParams) session.getAttribute(CONFIG_SESSION_KEY+"-"+displayName, PortletSession.APPLICATION_SCOPE);
+            if(results == null) {
+                results = loadConfigPropertiesByObjectName(request, adapterObjectName);
+                session.setAttribute(CONFIG_SESSION_KEY+"-"+displayName, results, PortletSession.APPLICATION_SCOPE);
+            }
+            return results;
+        } else {
+            throw new IllegalArgumentException();
+        }
+    }
+
+    public void processAction(ActionRequest actionRequest,
+            ActionResponse actionResponse) throws PortletException, IOException {
+        String mode = actionRequest.getParameter(MODE_KEY);
+        if(mode.equals(IMPORT_UPLOAD_MODE)) {
+            processImportUpload(actionRequest, actionResponse);
+            actionResponse.setRenderParameter(MODE_KEY, IMPORT_STATUS_MODE);
+            return;
+        }
+        PoolData data = new PoolData();
+        data.load(actionRequest);
+        if(mode.equals("process-"+SELECT_RDBMS_MODE)) {
+            DatabaseInfo info = null;
+            info = getDatabaseInfo(data);
+            if(info != null) {
+                data.rarPath = info.getRarPath();
+                if(info.isXA()) {
+                    data.adapterDisplayName="Unknown"; // will pick these up when we process the RA type in the render request
+                    data.adapterDescription="Unknown";
+                    actionResponse.setRenderParameter(MODE_KEY, EDIT_MODE);
+                } else {
+                    if(data.getDbtype().equals("Other")) {
+                        actionResponse.setRenderParameter(MODE_KEY, EDIT_MODE);
+                    } else {
+                        data.driverClass = info.getDriverClass();
+                        data.urlPrototype = info.getUrl();
+                        actionResponse.setRenderParameter(MODE_KEY, BASIC_PARAMS_MODE);
+                    }
+                }
+            } else {
+                actionResponse.setRenderParameter(MODE_KEY, SELECT_RDBMS_MODE);
+            }
+        } else if(mode.equals("process-"+DOWNLOAD_MODE)) {
+            String name = actionRequest.getParameter("driverName");
+            DriverDownloader.DriverInfo[] drivers = getDriverInfo(actionRequest);
+            DriverDownloader.DriverInfo found = null;
+            for (int i = 0; i < drivers.length; i++) {
+                DriverDownloader.DriverInfo driver = drivers[i];
+                if(driver.getName().equals(name)) {
+                    found = driver;
+                    break;
+                }
+            }
+            if(found != null) {
+                DriverDownloader downloader = new DriverDownloader();
+                WriteableRepository repo = PortletManager.getWritableRepositories(actionRequest)[0];
+                try {
+                    downloader.loadDriver(repo, found, new FileWriteMonitor() {
+                        public void writeStarted(String fileDescription) {
+                            System.out.println("Downloading "+fileDescription);
+                        }
+
+                        public void writeProgress(int bytes) {
+                            System.out.print("\rDownload progress: "+(bytes/1024)+"kB");
+                            System.out.flush();
+                        }
+
+                        public void writeComplete(int bytes) {
+                            System.out.println();
+                            System.out.println("Finished downloading "+bytes+"b");
+                        }
+                    });
+                    data.jar1 = found.getRepositoryURI();
+                } catch (IOException e) {
+                    log.error("Unable to download JDBC driver", e);
+                }
+            }
+            if(data.getDbtype() == null || data.getDbtype().equals("Other")) {
+                actionResponse.setRenderParameter(MODE_KEY, EDIT_MODE);
+            } else {
+                actionResponse.setRenderParameter(MODE_KEY, BASIC_PARAMS_MODE);
+            }
+        } else if(mode.equals("process-"+BASIC_PARAMS_MODE)) {
+            DatabaseInfo info = null;
+            info = getDatabaseInfo(data);
+            if(info != null) {
+                data.url = populateURL(info.getUrl(), info.getUrlParameters(), data.getUrlProperties());
+            }
+            if(attemptDriverLoad(actionRequest, data) != null) {
+                actionResponse.setRenderParameter(MODE_KEY, CONFIRM_URL_MODE);
+            } else {
+                actionResponse.setRenderParameter("driverError", "Unable to load driver "+data.driverClass);
+                actionResponse.setRenderParameter(MODE_KEY, BASIC_PARAMS_MODE);
+            }
+        } else if(mode.equals("process-"+CONFIRM_URL_MODE)) {
+            String test = actionRequest.getParameter("test");
+            if(test == null || test.equals("true")) {
+                String result = null;
+                String stack = null;
+                try {
+                    result = attemptConnect(actionRequest, data);
+                } catch (Exception e) {
+                    StringWriter writer = new StringWriter();
+                    PrintWriter temp = new PrintWriter(writer);
+                    e.printStackTrace(temp);
+                    temp.flush();
+                    temp.close();
+                    stack = writer.getBuffer().toString();
+                }
+                if(result != null) actionResponse.setRenderParameter("connectResult", result);
+                actionRequest.getPortletSession(true).setAttribute("connectError", stack);
+                actionResponse.setRenderParameter(MODE_KEY, TEST_CONNECTION_MODE);
+            } else {
+                save(actionRequest, actionResponse, data, false);
+            }
+        } else if(mode.equals(SAVE_MODE)) {
+            save(actionRequest, actionResponse, data, false);
+        } else if(mode.equals(SHOW_PLAN_MODE)) {
+            String plan = save(actionRequest, actionResponse, data, true);
+            actionRequest.getPortletSession(true).setAttribute("deploymentPlan", plan);
+            actionResponse.setRenderParameter(MODE_KEY, SHOW_PLAN_MODE);
+        } else if(mode.equals(EDIT_EXISTING_MODE)) {
+            final String name = actionRequest.getParameter("adapterObjectName");
+            loadConnectionFactory(actionRequest, name, data.getObjectName(), data);
+            actionResponse.setRenderParameter("adapterObjectName", name);
+            actionResponse.setRenderParameter(MODE_KEY, EDIT_MODE);
+        } else if(mode.equals(SELECT_RDBMS_MODE)) {
+            if(data.getAdapterDisplayName() == null) { // Set a default for a new pool
+                data.adapterDisplayName = "TranQL Generic JDBC Resource Adapter";
+            }
+            actionResponse.setRenderParameter(MODE_KEY, mode);
+        } else if(mode.equals(WEBLOGIC_IMPORT_MODE)) {
+            String domainDir = actionRequest.getParameter("weblogicDomainDir");
+            String libDir = actionRequest.getParameter("weblogicLibDir");
+            try {
+                DatabaseConversionStatus status = WebLogic81DatabaseConverter.convert(libDir, domainDir);
+                actionRequest.getPortletSession(true).setAttribute("ImportStatus", new ImportStatus(status));
+                actionResponse.setRenderParameter(MODE_KEY, IMPORT_STATUS_MODE);
+            } catch (Exception e) {
+                log.error("Unable to import", e);
+                actionResponse.setRenderParameter("from", actionRequest.getParameter("from"));
+                actionResponse.setRenderParameter(MODE_KEY, IMPORT_START_MODE);
+            }
+        } else if(mode.equals(IMPORT_START_MODE)) {
+            actionResponse.setRenderParameter("from", actionRequest.getParameter("from"));
+            actionResponse.setRenderParameter(MODE_KEY, mode);
+        } else if(mode.equals(IMPORT_EDIT_MODE)) {
+            ImportStatus status = getImportStatus(actionRequest);
+            int index = Integer.parseInt(actionRequest.getParameter("importIndex"));
+            status.setCurrentPoolIndex(index);
+            loadImportedData(data, status.getCurrentPool());
+            actionResponse.setRenderParameter(MODE_KEY, EDIT_MODE);
+        } else if(mode.equals(IMPORT_COMPLETE_MODE)) {
+            ImportStatus status = getImportStatus(actionRequest);
+            log.warn("Import Results:"); //todo: create a screen for this
+            log.warn("  "+status.getSkippedCount()+" ignored");
+            log.warn("  "+status.getStartedCount()+" reviewed but not deployed");
+            log.warn("  "+status.getPendingCount()+" not reviewed");
+            log.warn("  "+status.getFinishedCount()+" deployed");
+            actionRequest.getPortletSession().removeAttribute("ImportStatus");
+        } else {
+            actionResponse.setRenderParameter(MODE_KEY, mode);
+        }
+        data.store(actionResponse);
+    }
+
+    private void loadImportedData(PoolData data, ImportStatus.PoolProgress progress) {
+        if(!progress.getType().equals(ImportStatus.PoolProgress.TYPE_XA)) {
+            JDBCPool pool = (JDBCPool) progress.getPool();
+            data.dbtype = "Other";
+            data.adapterDisplayName = "TranQL Generic JDBC Resource Adapter";
+            data.blockingTimeout = getImportString(pool.getBlockingTimeoutMillis());
+            data.driverClass = pool.getDriverClass();
+            data.idleTimeout = pool.getIdleTimeoutMillis() == null ? null : Integer.toString(pool.getIdleTimeoutMillis().intValue() / (60 * 1000));
+            data.maxSize = getImportString(pool.getMaxSize());
+            data.minSize = getImportString(pool.getMinSize());
+            data.name = pool.getName();
+            data.password = pool.getPassword();
+            data.url = pool.getJdbcURL();
+            data.user = pool.getUsername();
+            if(pool.getDriverClass() != null) {
+                DatabaseInfo info = getDatabaseInfoFromDriver(data);
+                if(info != null) {
+                    data.rarPath = info.getRarPath();
+                    data.urlPrototype = info.getUrl();
+                } else {
+                    log.warn("Don't recognize database driver "+data.driverClass+"; Using default RAR file");
+                    data.rarPath = DatabaseInfo.getDefaultRARPath();
+                }
+            }
+        } else {
+            //todo: handle XA
+        }
+    }
+
+    private static String getImportString(Integer value) {
+        return value == null ? null : value.toString();
+    }
+
+    private boolean processImportUpload(ActionRequest request, ActionResponse response) throws PortletException {
+        String type = request.getParameter("importSource");
+        response.setRenderParameter("importSource", type);
+        if (!PortletFileUpload.isMultipartContent(request)) {
+            throw new PortletException("Expected file upload");
+        }
+
+        PortletFileUpload uploader = new PortletFileUpload(new DiskFileItemFactory());
+        try {
+            List items = uploader.parseRequest(request);
+            for (Iterator i = items.iterator(); i.hasNext();) {
+                FileItem item = (FileItem) i.next();
+                if (!item.isFormField()) {
+                    File file = File.createTempFile("geronimo-import", "");
+                    file.deleteOnExit();
+                    log.debug("Writing database pool import file to "+file.getAbsolutePath());
+                    item.write(file);
+                    DatabaseConversionStatus status = processImport(file, type);
+                    request.getPortletSession(true).setAttribute("ImportStatus", new ImportStatus(status));
+                    return true;
+                } else {
+                    throw new PortletException("Not expecting any form fields");
+                }
+            }
+        } catch(PortletException e) {
+            throw e;
+        } catch(Exception e) {
+            throw new PortletException(e);
+        }
+        return false;
+    }
+
+    private DatabaseConversionStatus processImport(File importFile, String type) throws PortletException, IOException {
+        if(type.equals("JBoss 4")) {
+            return JBoss4DatabaseConverter.convert(new FileReader(importFile));
+        } else if(type.equals("WebLogic 8.1")) {
+            return WebLogic81DatabaseConverter.convert(new FileReader(importFile));
+        } else {
+            throw new PortletException("Unknown import type '"+type+"'");
+        }
+    }
+
+    private ResourceAdapterParams loadConfigPropertiesByPath(PortletRequest request, String rarPath) {
+        DeploymentManager mgr = PortletManager.getDeploymentManager(request);
+        try {
+            URL url = getRAR(request, rarPath);
+            ConnectorDeployable deployable = new ConnectorDeployable(url);
+            final DDBeanRoot ddBeanRoot = deployable.getDDBeanRoot();
+            String adapterName = null, adapterDesc = null;
+            String[] test = ddBeanRoot.getText("connector/display-name");
+            if(test != null && test.length > 0) {
+                adapterName = test[0];
+            }
+            test = ddBeanRoot.getText("connector/description");
+            if(test != null && test.length > 0) {
+                adapterDesc = test[0];
+            }
+            DDBean[] definitions = ddBeanRoot.getChildBean("connector/resourceadapter/outbound-resourceadapter/connection-definition");
+            List configs = new ArrayList();
+            if(definitions != null) {
+                for (int i = 0; i < definitions.length; i++) {
+                    DDBean definition = definitions[i];
+                    String iface = definition.getText("connectionfactory-interface")[0];
+                    if(iface.equals("javax.sql.DataSource")) {
+                        DDBean[] beans = definition.getChildBean("config-property");
+                        for (int j = 0; j < beans.length; j++) {
+                            DDBean bean = beans[j];
+                            String name = bean.getText("config-property-name")[0].trim();
+                            String type = bean.getText("config-property-type")[0].trim();
+                            test = bean.getText("config-property-value");
+                            String value = test == null || test.length == 0 ? null : test[0].trim();
+                            test = bean.getText("description");
+                            String desc = test == null || test.length == 0 ? null : test[0].trim();
+                            configs.add(new ConfigParam(name, type, desc, value));
+                        }
+                    }
+                }
+            }
+            return new ResourceAdapterParams(adapterName, adapterDesc, (ConfigParam[]) configs.toArray(new ConfigParam[configs.size()]));
+        } catch (Exception e) {
+            log.error("Unable to read configuration properties", e);
+            return null;
+        } finally {
+            if(mgr != null) mgr.release();
+        }
+    }
+
+    private ResourceAdapterParams loadConfigPropertiesByObjectName(PortletRequest request, String objectName) {
+        ResourceAdapterModule module = (ResourceAdapterModule) PortletManager.getManagedBean(request, objectName);
+        String dd = module.getDeploymentDescriptor();
+        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
+        factory.setValidating(false);
+        factory.setNamespaceAware(true);
+        try {
+            DocumentBuilder builder = factory.newDocumentBuilder();
+            final StringReader reader = new StringReader(dd);
+            Document doc = builder.parse(new InputSource(reader));
+            reader.close();
+            Element elem = doc.getDocumentElement(); // connector
+            String displayName = getFirstText(elem.getElementsByTagName("display-name"));
+            String description = getFirstText(elem.getElementsByTagName("description"));
+            elem = (Element) elem.getElementsByTagName("resourceadapter").item(0);
+            elem = (Element) elem.getElementsByTagName("outbound-resourceadapter").item(0);
+            NodeList defs = elem.getElementsByTagName("connection-definition");
+            List all = new ArrayList();
+            for(int i=0; i<defs.getLength(); i++) {
+                final Element def = (Element)defs.item(i);
+                String iface = getFirstText(def.getElementsByTagName("connectionfactory-interface")).trim();
+                if(iface.equals("javax.sql.DataSource")) {
+                    NodeList configs = def.getElementsByTagName("config-property");
+                    for(int j=0; j<configs.getLength(); j++) {
+                        Element config = (Element) configs.item(j);
+                        String name = getFirstText(config.getElementsByTagName("config-property-name")).trim();
+                        String type = getFirstText(config.getElementsByTagName("config-property-type")).trim();
+                        String test = getFirstText(config.getElementsByTagName("config-property-value"));
+                        String value = test == null ? null : test.trim();
+                        test = getFirstText(config.getElementsByTagName("description"));
+                        String desc = test == null ? null : test.trim();
+                        all.add(new ConfigParam(name, type, desc, value));
+                    }
+                }
+            }
+            return new ResourceAdapterParams(displayName, description, (ConfigParam[]) all.toArray(new ConfigParam[all.size()]));
+        } catch (Exception e) {
+            log.error("Unable to read resource adapter DD", e);
+            return null;
+        }
+    }
+
+    private String getFirstText(NodeList list) {
+        if(list.getLength() == 0) {
+            return null;
+        }
+        Element first = (Element) list.item(0);
+        StringBuffer buf = new StringBuffer();
+        NodeList all = first.getChildNodes();
+        for(int i=0; i<all.getLength(); i++) {
+            Node node = all.item(i);
+            if(node.getNodeType() == Node.TEXT_NODE) {
+                buf.append(node.getNodeValue());
+            }
+        }
+        return buf.toString();
+    }
+
+    private void loadConnectionFactory(ActionRequest actionRequest, String adapterName, String factoryName, PoolData data) {
+        ResourceAdapterModule adapter = (ResourceAdapterModule) PortletManager.getManagedBean(actionRequest, adapterName);
+        JCAManagedConnectionFactory factory = (JCAManagedConnectionFactory) PortletManager.getManagedBean(actionRequest, factoryName);
+        data.adapterDisplayName = adapter.getDisplayName();
+        data.adapterDescription = adapter.getDescription();
+        try {
+            ObjectName oname = ObjectName.getInstance(factoryName);
+            data.name = oname.getKeyProperty("name");
+            if(data.isGeneric()) {
+                data.url = (String) factory.getConfigProperty("connectionURL");
+                data.driverClass = (String) factory.getConfigProperty("driver");
+                data.user = (String) factory.getConfigProperty("userName");
+                data.password = (String) factory.getConfigProperty("password");
+            } else {
+                ResourceAdapterParams params = getRARConfiguration(actionRequest, data.getRarPath(), data.getAdapterDisplayName(), adapterName);
+                for(int i=0; i<params.getConfigParams().length; i++) {
+                    ConfigParam cp = params.getConfigParams()[i];
+                    Object value = factory.getConfigProperty(cp.getName());
+                    data.properties.put("property-"+cp.getName(), value == null ? null : value.toString());
+                }
+            }
+        } catch (Exception e) {
+            log.error("Unable to look up connection property", e);
+        }
+        //todo: push the lookup into ManagementHelper
+        PoolingAttributes pool = (PoolingAttributes) PortletManager.getManagedBean(actionRequest, factory.getConnectionManager());
+        data.minSize = Integer.toString(pool.getPartitionMinSize());
+        data.maxSize = Integer.toString(pool.getPartitionMaxSize());
+        data.blockingTimeout = Integer.toString(pool.getBlockingTimeoutMilliseconds());
+        data.idleTimeout = Integer.toString(pool.getIdleTimeoutMinutes());
+
+    }
+
+    protected void doView(RenderRequest renderRequest, RenderResponse renderResponse) throws IOException, PortletException {
+        if (WindowState.MINIMIZED.equals(renderRequest.getWindowState())) {
+            return;
+        }
+        try {
+            String mode = renderRequest.getParameter(MODE_KEY);
+            PoolData data = new PoolData();
+            data.load(renderRequest);
+            renderRequest.setAttribute("pool", data);
+            // If not headed anywhere in particular, send to list
+            if(mode == null || mode.equals("")) {
+                mode = LIST_MODE;
+            }
+            // If headed to list but there's an import in progress, redirect to import status
+            if(mode.equals(LIST_MODE) && getImportStatus(renderRequest) != null) {
+                mode = IMPORT_STATUS_MODE;
+            }
+
+            if(mode.equals(LIST_MODE)) {
+                renderList(renderRequest, renderResponse);
+            } else if(mode.equals(EDIT_MODE)) {
+                renderEdit(renderRequest, renderResponse, data);
+            } else if(mode.equals(SELECT_RDBMS_MODE)) {
+                renderSelectRDBMS(renderRequest, renderResponse);
+            } else if(mode.equals(DOWNLOAD_MODE)) {
+                renderDownload(renderRequest, renderResponse);
+            } else if(mode.equals(BASIC_PARAMS_MODE)) {
+                renderBasicParams(renderRequest, renderResponse, data);
+            } else if(mode.equals(CONFIRM_URL_MODE)) {
+                renderConfirmURL(renderRequest, renderResponse);
+            } else if(mode.equals(TEST_CONNECTION_MODE)) {
+                renderTestConnection(renderRequest, renderResponse);
+            } else if(mode.equals(SHOW_PLAN_MODE)) {
+                renderPlan(renderRequest, renderResponse, data);
+            } else if(mode.equals(IMPORT_START_MODE)) {
+                renderImportUploadForm(renderRequest, renderResponse);
+            } else if(mode.equals(IMPORT_STATUS_MODE)) {
+                renderImportStatus(renderRequest, renderResponse);
+            } else if(mode.equals(USAGE_MODE)) {
+                renderUsage(renderRequest, renderResponse);
+            }
+        } catch (Throwable e) {
+            log.error("Unable to render portlet", e);
+        }
+    }
+
+    private void renderUsage(RenderRequest request, RenderResponse response) throws IOException, PortletException {
+        usageView.include(request, response);
+    }
+
+    private void renderImportStatus(RenderRequest request, RenderResponse response) throws IOException, PortletException {
+        request.setAttribute("status", getImportStatus(request));
+        populatePoolList(request);
+        importStatusView.include(request, response);
+    }
+
+    private void renderImportUploadForm(RenderRequest request, RenderResponse response) throws IOException, PortletException {
+        request.setAttribute("from", request.getParameter("from"));
+        importUploadView.include(request, response);
+    }
+
+    private void renderList(RenderRequest renderRequest, RenderResponse renderResponse) throws IOException, PortletException {
+        populatePoolList(renderRequest);
+        listView.include(renderRequest, renderResponse);
+    }
+
+    private void populatePoolList(PortletRequest renderRequest) {
+        ResourceAdapterModule[] modules = PortletManager.getOutboundRAModules(renderRequest, "javax.sql.DataSource");
+        List list = new ArrayList();
+        for (int i = 0; i < modules.length; i++) {
+            ResourceAdapterModule module = modules[i];
+            JCAManagedConnectionFactory[] databases = PortletManager.getOutboundFactoriesForRA(renderRequest, module, "javax.sql.DataSource");
+            for (int j = 0; j < databases.length; j++) {
+                JCAManagedConnectionFactory db = databases[j];
+                try {
+                    ObjectName name = ObjectName.getInstance(db.getObjectName());
+                    list.add(new ConnectionPool(ObjectName.getInstance(module.getObjectName()), db.getObjectName(), name.getKeyProperty(NameFactory.J2EE_NAME), ((GeronimoManagedBean)db).getState()));
+                } catch (MalformedObjectNameException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+        Collections.sort(list);
+        renderRequest.setAttribute("pools", list);
+    }
+
+    private void renderEdit(RenderRequest renderRequest, RenderResponse renderResponse, PoolData data) throws IOException, PortletException {
+        if(data.objectName == null || data.objectName.equals("")) {
+            loadDriverJARList(renderRequest);
+        }
+        if(!data.isGeneric()) {
+            ResourceAdapterParams params = getRARConfiguration(renderRequest, data.getRarPath(), data.getAdapterDisplayName(), renderRequest.getParameter("adapterObjectName"));
+            data.adapterDisplayName = params.getDisplayName();
+            data.adapterDescription = params.getDescription();
+            Map map = new HashMap();
+            boolean more = false;
+            for (int i = 0; i < params.getConfigParams().length; i++) {
+                ConfigParam param = params.getConfigParams()[i];
+                if(!data.properties.containsKey("property-"+param.getName())) {
+                    data.properties.put("property-"+param.getName(), param.getDefaultValue());
+                    more = true;
+                }
+                map.put("property-"+param.getName(), param);
+            }
+            if(more) {
+                data.loadPropertyNames();
+            }
+            renderRequest.setAttribute("ConfigParams", map);
+        }
+        editView.include(renderRequest, renderResponse);
+    }
+
+    private void renderSelectRDBMS(RenderRequest renderRequest, RenderResponse renderResponse) throws IOException, PortletException {
+        renderRequest.setAttribute("databases", DatabaseInfo.ALL_DATABASES);
+        selectRDBMSView.include(renderRequest, renderResponse);
+    }
+
+    private void renderDownload(RenderRequest renderRequest, RenderResponse renderResponse) throws IOException, PortletException {
+        renderRequest.setAttribute("drivers", getDriverInfo(renderRequest));
+        downloadView.include(renderRequest, renderResponse);
+    }
+
+    private void renderBasicParams(RenderRequest renderRequest, RenderResponse renderResponse, PoolData data) throws IOException, PortletException {
+        loadDriverJARList(renderRequest);
+        // Make sure all properties available for the DB are listed
+        DatabaseInfo info = getDatabaseInfo(data);
+        if(info != null) {
+            String[] params = info.getUrlParameters();
+            for (int i = 0; i < params.length; i++) {
+                String param = params[i];
+                final String key = "urlproperty-"+param;
+                if(!data.getUrlProperties().containsKey(key)) {
+                    data.getUrlProperties().put(key, param.equalsIgnoreCase("port") && info.getDefaultPort() > 0 ? new Integer(info.getDefaultPort()) : null);
+                }
+            }
+        }
+        // Pass on errors
+        renderRequest.setAttribute("driverError", renderRequest.getParameter("driverError"));
+
+        basicParamsView.include(renderRequest, renderResponse);
+    }
+
+    private void loadDriverJARList(RenderRequest renderRequest) {
+        // List the available JARs
+        List list = new ArrayList();
+        ListableRepository[] repos = PortletManager.getListableRepositories(renderRequest);
+        for (int i = 0; i < repos.length; i++) {
+            ListableRepository repo = repos[i];
+            try {
+                final URI[] uris = repo.listURIs();
+                outer:
+                for (int j = 0; j < uris.length; j++) {
+                    if(uris[j] == null) {
+                        continue; // probably a JAR lacks a version number in the name, etc.
+                    }
+                    String test = uris[j].toString();
+                    for (int k = 0; k < SKIP_ENTRIES_WITH.length; k++) {
+                        String skip = SKIP_ENTRIES_WITH[k];
+                        if(test.indexOf(skip) > -1) {
+                            continue outer;
+                        }
+                    }
+                    list.add(test);
+                }
+            } catch (URISyntaxException e) {
+                e.printStackTrace();
+            }
+        }
+        Collections.sort(list);
+        renderRequest.setAttribute("jars", list);
+    }
+
+    private void renderConfirmURL(RenderRequest renderRequest, RenderResponse renderResponse) throws IOException, PortletException {
+        confirmURLView.include(renderRequest, renderResponse);
+    }
+
+    private void renderTestConnection(RenderRequest renderRequest, RenderResponse renderResponse) throws IOException, PortletException {
+        // Pass on results
+        renderRequest.setAttribute("connectResult", renderRequest.getParameter("connectResult"));
+        renderRequest.setAttribute("connectError", renderRequest.getPortletSession().getAttribute("connectError"));
+        testConnectionView.include(renderRequest, renderResponse);
+    }
+
+    private void renderPlan(RenderRequest renderRequest, RenderResponse renderResponse, PoolData data) throws IOException, PortletException {
+        // Pass on results
+        renderRequest.setAttribute("deploymentPlan", renderRequest.getPortletSession().getAttribute("deploymentPlan"));
+        // Digest the RAR URI
+        String path = PortletManager.getRepositoryEntry(renderRequest, data.getRarPath()).getPath();
+        String base = PortletManager.getServerInfo(renderRequest).getCurrentBaseDirectory();
+        if(base != null && path.startsWith(base)) {
+            path = path.substring(base.length());
+            if(path.startsWith("/")) {
+                path = path.substring(1);
+            }
+        } else {
+            int pos = path.lastIndexOf('/');
+            path = path.substring(pos+1);
+        }
+        renderRequest.setAttribute("rarRelativePath", path);
+
+        planView.include(renderRequest, renderResponse);
+    }
+
+    private static String attemptConnect(PortletRequest request, PoolData data) throws SQLException, IllegalAccessException, InstantiationException {
+        Class driverClass = attemptDriverLoad(request, data);
+        Driver driver = (Driver) driverClass.newInstance();
+        if(driver.acceptsURL(data.url)) {
+            Properties props = new Properties();
+            if(data.user != null) {
+                props.put("user", data.user);
+            }
+            if(data.password != null) {
+                props.put("password", data.password);
+            }
+            Connection con = null;
+            try {
+                con = driver.connect(data.url, props);
+                final DatabaseMetaData metaData = con.getMetaData();
+                return metaData.getDatabaseProductName()+" "+metaData.getDatabaseProductVersion();
+            } finally {
+                if(con != null) try{con.close();}catch(SQLException e) {}
+            }
+        } else throw new SQLException("Driver "+data.getDriverClass()+" does not accept URL "+data.url);
+    }
+
+    private static String save(PortletRequest request, ActionResponse response, PoolData data, boolean planOnly) {
+        ImportStatus status = getImportStatus(request);
+        if(data.objectName == null || data.objectName.equals("")) { // we're creating a new pool
+            data.name = data.name.replaceAll("\\s", "");
+            DeploymentManager mgr = PortletManager.getDeploymentManager(request);
+            try {
+                URL url = getRAR(request, data.getRarPath());
+                String str = url.toString();
+                if(str.indexOf(' ') > -1) {
+                    url = new URL(str.replaceAll(" ", "%20")); // try to avoid problems with spaces in path on Windows
+                }
+                ConnectorDeployable deployable = new ConnectorDeployable(url);
+                DeploymentConfiguration config = mgr.createConfiguration(deployable);
+                final DDBeanRoot ddBeanRoot = deployable.getDDBeanRoot();
+                Connector15DCBRoot root = (Connector15DCBRoot) config.getDConfigBeanRoot(ddBeanRoot);
+                ConnectorDCB connector = (ConnectorDCB) root.getDConfigBean(ddBeanRoot.getChildBean(root.getXpaths()[0])[0]);
+                connector.setConfigID("console-db-pool-"+data.getName());
+                if(data.jar1 != null && !data.jar1.equals("")) {
+                    Dependency dep = new Dependency();
+                    connector.setDependency(new Dependency[]{dep});
+                    dep.setURI(data.jar1);
+                }
+                if(data.jar2 != null && !data.jar2.equals("")) {
+                    Dependency dep = new Dependency();
+                    Dependency[] old = connector.getDependency();
+                    Dependency[] longer = new Dependency[old.length+1];
+                    System.arraycopy(old, 0, longer, 0, old.length);
+                    longer[old.length] = dep;
+                    connector.setDependency(longer);
+                    dep.setURI(data.jar2);
+                }
+                if(data.jar3 != null && !data.jar3.equals("")) {
+                    Dependency dep = new Dependency();
+                    Dependency[] old = connector.getDependency();
+                    Dependency[] longer = new Dependency[old.length+1];
+                    System.arraycopy(old, 0, longer, 0, old.length);
+                    longer[old.length] = dep;
+                    connector.setDependency(longer);
+                    dep.setURI(data.jar3);
+                }
+                ResourceAdapter adapter = connector.getResourceAdapter()[0];
+                ConnectionDefinition definition = new ConnectionDefinition();
+                adapter.setConnectionDefinition(new ConnectionDefinition[]{definition});
+                definition.setConnectionFactoryInterface("javax.sql.DataSource");
+                ConnectionDefinitionInstance instance = new ConnectionDefinitionInstance();
+                definition.setConnectionInstance(new ConnectionDefinitionInstance[]{instance});
+                instance.setName(data.getName());
+                ConfigPropertySetting[] settings = instance.getConfigPropertySetting();
+                if(data.isGeneric()) { // it's a generic TranQL JDBC pool
+                    for (int i = 0; i < settings.length; i++) {
+                        ConfigPropertySetting setting = settings[i];
+                        if(setting.getName().equals("UserName")) {
+                            setting.setValue(data.user);
+                        } else if(setting.getName().equals("Password")) {
+                            setting.setValue(data.password);
+                        } else if(setting.getName().equals("ConnectionURL")) {
+                            setting.setValue(data.url);
+                        } else if(setting.getName().equals("Driver")) {
+                            setting.setValue(data.driverClass);
+                        }
+                    }
+                } else { // it's an XA driver or non-TranQL RA
+                    for (int i = 0; i < settings.length; i++) {
+                        ConfigPropertySetting setting = settings[i];
+                        String value = (String) data.properties.get("property-"+setting.getName());
+                        setting.setValue(value == null ? "" : value);
+                    }
+                }
+                ConnectionManager manager = instance.getConnectionManager();
+                manager.setTransactionLocal(true);
+                SinglePool pool = new SinglePool();
+                manager.setPoolSingle(pool);
+                pool.setMatchOne(true);
+                // Max Size needs to be set before the minimum.  This is because 
+                // the connection manager will constrain the minimum based on the 
+                // current maximum value in the pool.  We might consider adding a  
+                // setPoolConstraints method to allow specifying both at the same time.
+                if(data.maxSize != null && !data.maxSize.equals("")) {
+                    pool.setMaxSize(new Integer(data.maxSize));
+                }
+                if(data.minSize != null && !data.minSize.equals("")) {
+                    pool.setMinSize(new Integer(data.minSize));
+                }
+                if(data.blockingTimeout != null && !data.blockingTimeout.equals("")) {
+                    pool.setBlockingTimeoutMillis(new Integer(data.blockingTimeout));
+                }
+                if(data.idleTimeout != null && !data.idleTimeout.equals("")) {
+                    pool.setIdleTimeoutMinutes(new Integer(data.idleTimeout));
+                }
+                if(planOnly) {
+                    ByteArrayOutputStream out = new ByteArrayOutputStream();
+                    config.save(out);
+                    out.close();
+                    return new String(out.toByteArray(), "US-ASCII");
+                } else {
+                    File tempFile = File.createTempFile("console-deployment",".xml");
+                    tempFile.deleteOnExit();
+                    log.debug("Writing database pool deployment plan to "+tempFile.getAbsolutePath());
+                    BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(tempFile));
+                    config.save(out);
+                    out.flush();
+                    out.close();
+                    Target[] targets = mgr.getTargets();
+                    ProgressObject po = mgr.distribute(targets, new File(url.getPath()), tempFile);
+                    waitForProgress(po);
+                    if(po.getDeploymentStatus().isCompleted()) {
+                        TargetModuleID[] ids = po.getResultTargetModuleIDs();
+                        po = mgr.start(ids);
+                        waitForProgress(po);
+                        if(po.getDeploymentStatus().isCompleted()) {
+                            ids = po.getResultTargetModuleIDs();
+                            if(status != null) {
+                                status.getCurrentPool().setName(data.getName());
+                                status.getCurrentPool().setConfigurationName(ids[0].getModuleID());
+                                status.getCurrentPool().setFinished(true);
+                                response.setRenderParameter(MODE_KEY, IMPORT_STATUS_MODE);
+                            }
+                            System.out.println("Deployment completed successfully!");
+                        }
+                    }
+                }
+            } catch (Exception e) {
+                log.error("Unable to save connection pool", e);
+            } finally {
+                if(mgr != null) mgr.release();
+            }
+        } else { // We're saving updates to an existing pool
+            if(planOnly) {
+                throw new UnsupportedOperationException("Can't update a plan for an existing deployment");
+            }
+            try {
+                JCAManagedConnectionFactory factory = (JCAManagedConnectionFactory) PortletManager.getManagedBean(request, data.getObjectName());
+                if(data.isGeneric()) {
+                    factory.setConfigProperty("connectionURL", data.getUrl());
+                    factory.setConfigProperty("userName", data.getUser());
+                    factory.setConfigProperty("password", data.getPassword());
+                } else {
+                    for (Iterator it = data.getProperties().entrySet().iterator(); it.hasNext();) {
+                        Map.Entry entry = (Map.Entry) it.next();
+                        factory.setConfigProperty(((String) entry.getKey()).substring("property-".length()), entry.getValue());
+                    }
+                }
+                //todo: push the lookup into ManagementHelper
+                PoolingAttributes pool = (PoolingAttributes) PortletManager.getManagedBean(request, factory.getConnectionManager());
+                pool.setPartitionMinSize(data.minSize == null || data.minSize.equals("") ? 0 : Integer.parseInt(data.minSize));
+                pool.setPartitionMaxSize(data.maxSize == null || data.maxSize.equals("") ? 10 : Integer.parseInt(data.maxSize));
+                pool.setBlockingTimeoutMilliseconds(data.blockingTimeout == null || data.blockingTimeout.equals("") ? 5000 : Integer.parseInt(data.blockingTimeout));
+                pool.setIdleTimeoutMinutes(data.idleTimeout == null || data.idleTimeout.equals("") ? 15 : Integer.parseInt(data.idleTimeout));
+            } catch (Exception e) {
+                log.error("Unable to save connection pool", e);
+            }
+        }
+        return null;
+    }
+
+    private static void waitForProgress(ProgressObject po) {
+        while(po.getDeploymentStatus().isRunning()) {
+            try {
+                Thread.sleep(100);
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    private static ImportStatus getImportStatus(PortletRequest request) {
+        return (ImportStatus) request.getPortletSession(true).getAttribute("ImportStatus");
+    }
+
+    private static URL getRAR(PortletRequest request, String rarPath) {
+        try {
+            URI uri = new URI(rarPath);
+            Repository[] repos = PortletManager.getRepositories(request);
+            for (int i = 0; i < repos.length; i++) {
+                Repository repo = repos[i];
+                URL url = repo.getURL(uri);
+                if(url != null && url.getProtocol().equals("file")) {
+                    File file = new File(url.getPath());
+                    if(file.exists() && file.canRead() && !file.isDirectory()) {
+                        return url;
+                    }
+                }
+            }
+        } catch (URISyntaxException e) {
+            e.printStackTrace();
+        } catch (MalformedURLException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    /**
+     * WARNING: This method relies on having access to the same repository
+     * URLs as the server uses.
+     */
+    private static Class attemptDriverLoad(PortletRequest request, PoolData data) {
+        List list = new ArrayList();
+        try {
+            URI one = data.getJar1() == null ? null : new URI(data.getJar1());
+            URI two = data.getJar2() == null ? null : new URI(data.getJar2());
+            URI three = data.getJar3() == null ? null : new URI(data.getJar3());
+
+            ListableRepository[] repos = PortletManager.getListableRepositories(request);
+            for (int i = 0; i < repos.length; i++) {
+                ListableRepository repo = repos[i];
+                if(one != null) {
+                    URL url = repo.getURL(one);
+                    if(url != null) {
+                        list.add(url);
+                        one = null;
+                    }
+                }
+                if(two != null) {
+                    URL url = repo.getURL(two);
+                    if(url != null) {
+                        list.add(url);
+                        two = null;
+                    }
+                }
+                if(three != null) {
+                    URL url = repo.getURL(three);
+                    if(url != null) {
+                        list.add(url);
+                        three = null;
+                    }
+                }
+            }
+            URLClassLoader loader = new URLClassLoader((URL[]) list.toArray(new URL[list.size()]), DatabasePoolPortlet.class.getClassLoader());
+            try {
+                return loader.loadClass(data.driverClass);
+            } catch (ClassNotFoundException e) {
+                return null;
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    private static String populateURL(String url, String[] keys, Map properties) {
+        for (int i = 0; i < keys.length; i++) {
+            String key = keys[i];
+            String value = (String) properties.get("urlproperty-"+key);
+            if(value == null || value.equals("")) {
+                int begin = url.indexOf("<"+key+">");
+                int end = begin + key.length() + 2;
+                for(int j=begin-1; j>=0; j--) {
+                    char c = url.charAt(j);
+                    if(c == ';' || c == ':') {
+                        begin = j;
+                        break;
+                    } else if(c == '/') {
+                        if(url.length() > end && url.charAt(end) == '/') {
+                            begin = j; // Don't leave // if foo is null for /<foo>/
+                        }
+                        break;
+                    }
+                }
+                url = url.substring(0, begin)+url.substring(end);
+            } else {
+                url = url.replaceAll("<"+key+">", value);
+            }
+        }
+        return url;
+    }
+
+    private static DatabaseInfo getDatabaseInfo(PoolData data) {
+        DatabaseInfo info = null;
+        for (int i = 0; i < DatabaseInfo.ALL_DATABASES.length; i++) {
+            DatabaseInfo next = DatabaseInfo.ALL_DATABASES[i];
+            if(next.getName().equals(data.getDbtype())) {
+                info = next;
+                break;
+            }
+        }
+        return info;
+    }
+
+    private static DatabaseInfo getDatabaseInfoFromDriver(PoolData data) {
+        DatabaseInfo info = null;
+        for (int i = 0; i < DatabaseInfo.ALL_DATABASES.length; i++) {
+            DatabaseInfo next = DatabaseInfo.ALL_DATABASES[i];
+            if(next.getDriverClass() != null && next.getDriverClass().equals(data.getDriverClass())) {
+                info = next;
+                break;
+            }
+        }
+        return info;
+    }
+
+    public static class PoolData implements Serializable {
+        private String name;
+        private String dbtype;
+        private String user;
+        private String password;
+        private Map properties = new HashMap(); // Configuration for non-Generic drivers
+        private Map urlProperties = new HashMap(); // URL substitution for Generic drivers
+        private Map propertyNames; //todo: store these in the ConfigParam instead
+        private String driverClass;
+        private String url;
+        private String urlPrototype;
+        private String jar1;
+        private String jar2;
+        private String jar3;
+        private String minSize;
+        private String maxSize;
+        private String blockingTimeout;
+        private String idleTimeout;
+        private String objectName;
+        private String adapterDisplayName;
+        private String adapterDescription;
+        private String rarPath;
+        private String importSource;
+        private Map objectNameMap; // generated as needed, don't need to read/write it
+
+        public void load(PortletRequest request) {
+            name = request.getParameter("name");
+            if(name != null && name.equals("")) name = null;
+            driverClass = request.getParameter("driverClass");
+            if(driverClass != null && driverClass.equals("")) driverClass = null;
+            dbtype = request.getParameter("dbtype");
+            if(dbtype != null && dbtype.equals("")) dbtype = null;
+            user = request.getParameter("user");
+            if(user != null && user.equals("")) user = null;
+            password = request.getParameter("password");
+            if(password != null && password.equals("")) password = null;
+            url = request.getParameter("url");
+            if(url != null && url.equals("")) {
+                url = null;
+            } else if(url != null && url.indexOf("%3B") > -1) {
+                url = url.replaceAll("%3B", ";"); // attempt to work around Pluto/Tomcat error with ; in a stored value
+            }
+            urlPrototype = request.getParameter("urlPrototype");
+            if(urlPrototype != null && urlPrototype.equals("")) urlPrototype = null;
+            jar1 = request.getParameter("jar1");
+            if(jar1 != null && jar1.equals("")) jar1 = null;
+            jar2 = request.getParameter("jar2");
+            if(jar2 != null && jar2.equals("")) jar2 = null;
+            jar3 = request.getParameter("jar3");
+            if(jar3 != null && jar3.equals("")) jar3 = null;
+            minSize = request.getParameter("minSize");
+            if(minSize != null && minSize.equals("")) minSize = null;
+            maxSize = request.getParameter("maxSize");
+            if(maxSize != null && maxSize.equals("")) maxSize = null;
+            blockingTimeout = request.getParameter("blockingTimeout");
+            if(blockingTimeout != null && blockingTimeout.equals("")) blockingTimeout = null;
+            idleTimeout = request.getParameter("idleTimeout");
+            if(idleTimeout != null && idleTimeout.equals("")) idleTimeout = null;
+            objectName = request.getParameter("objectName");
+            if(objectName != null && objectName.equals("")) objectName = null;
+            adapterDisplayName = request.getParameter("adapterDisplayName");
+            if(adapterDisplayName != null && adapterDisplayName.equals("")) adapterDisplayName = null;
+            adapterDescription = request.getParameter("adapterDescription");
+            if(adapterDescription != null && adapterDescription.equals("")) adapterDescription = null;
+            rarPath = request.getParameter("rarPath");
+            if(rarPath != null && rarPath.equals("")) rarPath = null;
+            importSource = request.getParameter("importSource");
+            if(importSource != null && importSource.equals("")) importSource = null;
+            Map map = request.getParameterMap();
+            propertyNames = new HashMap();
+            for (Iterator it = map.keySet().iterator(); it.hasNext();) {
+                String key = (String) it.next();
+                if(key.startsWith("urlproperty-")) {
+                    urlProperties.put(key, request.getParameter(key));
+                } else if(key.startsWith("property-")) {
+                    properties.put(key, request.getParameter(key));
+                    propertyNames.put(key, getPropertyName(key));
+                }
+            }
+        }
+
+        public void loadPropertyNames() {
+            propertyNames = new HashMap();
+            for (Iterator it = properties.keySet().iterator(); it.hasNext();) {
+                String key = (String) it.next();
+                propertyNames.put(key, getPropertyName(key));
+            }
+        }
+
+        private static String getPropertyName(String key) {
+            int pos = key.indexOf('-');
+            key = Character.toUpperCase(key.charAt(pos+1))+key.substring(pos+2);
+            StringBuffer buf = new StringBuffer();
+            pos = 0;
+            for(int i=1; i<key.length(); i++) {
+                if(Character.isUpperCase(key.charAt(i))) {
+                    if(Character.isUpperCase(key.charAt(i-1))) { // ongoing capitalized word
+
+                    } else { // start of a new word
+                        buf.append(key.substring(pos, i)).append(" ");
+                        pos = i;
+                    }
+                } else {
+                    if(Character.isUpperCase(key.charAt(i-1)) && i-pos > 1) { // first lower-case after a series of caps
+                        buf.append(key.substring(pos, i-1)).append(" ");
+                        pos = i-1;
+                    }
+                }
+            }
+            buf.append(key.substring(pos));
+            return buf.toString();
+        }
+
+        public void store(ActionResponse response) {
+            if(name != null) response.setRenderParameter("name", name);
+            if(dbtype != null) response.setRenderParameter("dbtype", dbtype);
+            if(driverClass != null) response.setRenderParameter("driverClass", driverClass);
+            if(user != null) response.setRenderParameter("user", user);
+            if(password != null) response.setRenderParameter("password", password);
+            if(url != null) { // attempt to work around Pluto/Tomcat error with ; in a stored value
+                response.setRenderParameter("url", url.replaceAll(";", "%3B"));
+            }
+            if(urlPrototype != null) response.setRenderParameter("urlPrototype", urlPrototype);
+            if(jar1 != null) response.setRenderParameter("jar1", jar1);
+            if(jar2 != null) response.setRenderParameter("jar2", jar2);
+            if(jar3 != null) response.setRenderParameter("jar3", jar3);
+            if(minSize != null) response.setRenderParameter("minSize", minSize);
+            if(maxSize != null) response.setRenderParameter("maxSize", maxSize);
+            if(blockingTimeout != null) response.setRenderParameter("blockingTimeout", blockingTimeout);
+            if(idleTimeout != null) response.setRenderParameter("idleTimeout", idleTimeout);
+            if(objectName != null) response.setRenderParameter("objectName", objectName);
+            if(adapterDisplayName != null) response.setRenderParameter("adapterDisplayName", adapterDisplayName);
+            if(adapterDescription != null) response.setRenderParameter("adapterDescription", adapterDescription);
+            if(importSource != null) response.setRenderParameter("importSource", importSource);
+            if(rarPath != null) response.setRenderParameter("rarPath", rarPath);
+            for (Iterator it = urlProperties.entrySet().iterator(); it.hasNext();) {
+                Map.Entry entry = (Map.Entry) it.next();
+                if(entry.getValue() != null) {
+                    response.setRenderParameter((String)entry.getKey(), (String)entry.getValue());
+                }
+            }
+            for (Iterator it = properties.entrySet().iterator(); it.hasNext();) {
+                Map.Entry entry = (Map.Entry) it.next();
+                if(entry.getValue() != null) {
+                    response.setRenderParameter((String)entry.getKey(), (String)entry.getValue());
+                }
+            }
+        }
+
+        public String getName() {
+            return name;
+        }
+
+        public String getDbtype() {
+            return dbtype;
+        }
+
+        public String getUser() {
+            return user;
+        }
+
+        public String getPassword() {
+            return password;
+        }
+
+        public Map getProperties() {
+            return properties;
+        }
+
+        public Map getPropertyNames() {
+            return propertyNames;
+        }
+
+        public Map getUrlProperties() {
+            return urlProperties;
+        }
+
+        public String getUrl() {
+            return url;
+        }
+
+        public String getJar1() {
+            return jar1;
+        }
+
+        public String getJar2() {
+            return jar2;
+        }
+
+        public String getJar3() {
+            return jar3;
+        }
+
+        public String getMinSize() {
+            return minSize;
+        }
+
+        public String getMaxSize() {
+            return maxSize;
+        }
+
+        public String getBlockingTimeout() {
+            return blockingTimeout;
+        }
+
+        public String getIdleTimeout() {
+            return idleTimeout;
+        }
+
+        public String getDriverClass() {
+            return driverClass;
+        }
+
+        public String getUrlPrototype() {
+            return urlPrototype;
+        }
+
+        public String getObjectName() {
+            return objectName;
+        }
+
+        public String getAdapterDisplayName() {
+            return adapterDisplayName;
+        }
+
+        public String getAdapterDescription() {
+            return adapterDescription;
+        }
+
+        public String getRarPath() {
+            return rarPath;
+        }
+
+        public boolean isGeneric() {
+            //todo: is there any better way to tell?
+            return adapterDisplayName == null || adapterDisplayName.equals("TranQL Generic JDBC Resource Adapter");
+        }
+
+        public String getImportSource() {
+            return importSource;
+        }
+
+        public Map getObjectNameMap() {
+            if(objectName == null) return Collections.EMPTY_MAP;
+            if(objectNameMap != null) return objectNameMap;
+            try {
+                ObjectName name = new ObjectName(objectName);
+                objectNameMap = new HashMap(name.getKeyPropertyList());
+                objectNameMap.put("domain", name.getDomain());
+                return objectNameMap;
+            } catch (MalformedObjectNameException e) {
+                return Collections.EMPTY_MAP;
+            }
+        }
+    }
+
+    public static class ConnectionPool implements Serializable, Comparable {
+        private final String adapterObjectName;
+        private final String factoryObjectName;
+        private final String name;
+        private final String parentName;
+        private final int state;
+
+        public ConnectionPool(ObjectName adapterObjectName, String factoryObjectName, String name, int state) {
+            this.adapterObjectName = adapterObjectName.getCanonicalName();
+            String parent = adapterObjectName.getKeyProperty(NameFactory.J2EE_APPLICATION);
+            if(parent != null && parent.equals("null")) {
+                parent = null;
+            }
+            parentName = parent;
+            this.factoryObjectName = factoryObjectName;
+            this.name = name;
+            this.state = state;
+        }
+
+        public String getAdapterObjectName() {
+            return adapterObjectName;
+        }
+
+        public String getFactoryObjectName() {
+            return factoryObjectName;
+        }
+
+        public String getName() {
+            return name;
+        }
+
+        public String getParentName() {
+            return parentName;
+        }
+
+        public int getState() {
+            return state;
+        }
+
+        public String getStateName() {
+            return State.toString(state);
+        }
+
+        public int compareTo(Object o) {
+            final ConnectionPool pool = (ConnectionPool)o;
+            int names = name.compareTo(pool.name);
+            if(parentName == null) {
+                if(pool.parentName == null) {
+                    return names;
+                } else {
+                    return -1;
+                }
+            } else {
+                if(pool.parentName == null) {
+                    return 1;
+                } else {
+                    int test = parentName.compareTo(pool.parentName);
+                    if(test != 0) {
+                        return test;
+                    } else {
+                        return names;
+                    }
+                }
+            }
+        }
+    }
+
+    public static class ResourceAdapterParams {
+        private String displayName;
+        private String description;
+        private ConfigParam[] configParams;
+
+        public ResourceAdapterParams(String displayName, String description, ConfigParam[] configParams) {
+            this.displayName = displayName;
+            this.description = description;
+            this.configParams = configParams;
+        }
+
+        public String getDisplayName() {
+            return displayName;
+        }
+
+        public String getDescription() {
+            return description;
+        }
+
+        public ConfigParam[] getConfigParams() {
+            return configParams;
+        }
+    }
+
+    public static class ConfigParam {
+        private String name;
+        private String type;
+        private String description;
+        private String defaultValue;
+
+        public ConfigParam(String name, String type, String description, String defaultValue) {
+            this.name = name;
+            this.type = type;
+            this.description = description;
+            this.defaultValue = defaultValue;
+        }
+
+        public String getName() {
+            return name;
+        }
+
+        public String getType() {
+            return type;
+        }
+
+        public String getDescription() {
+            return description;
+        }
+
+        public String getDefaultValue() {
+            return defaultValue;
+        }
+    }
+}

Propchange: geronimo/trunk/applications/console/console-standard/src/java/org/apache/geronimo/console/databasemanager/wizard/DatabasePoolPortlet.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: geronimo/trunk/applications/console/console-standard/src/java/org/apache/geronimo/console/databasemanager/wizard/DatabasePoolPortlet.java
------------------------------------------------------------------------------
    svn:keywords = Rev Date

Propchange: geronimo/trunk/applications/console/console-standard/src/java/org/apache/geronimo/console/databasemanager/wizard/DatabasePoolPortlet.java
------------------------------------------------------------------------------
    svn:mime-type = text/plain

Added: geronimo/trunk/applications/console/console-standard/src/java/org/apache/geronimo/console/databasemanager/wizard/DriverDownloader.java
URL: http://svn.apache.org/viewcvs/geronimo/trunk/applications/console/console-standard/src/java/org/apache/geronimo/console/databasemanager/wizard/DriverDownloader.java?rev=393787&view=auto
==============================================================================
--- geronimo/trunk/applications/console/console-standard/src/java/org/apache/geronimo/console/databasemanager/wizard/DriverDownloader.java (added)
+++ geronimo/trunk/applications/console/console-standard/src/java/org/apache/geronimo/console/databasemanager/wizard/DriverDownloader.java Thu Apr 13 04:34:08 2006
@@ -0,0 +1,259 @@
+/**
+ *
+ * Copyright 2003-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.geronimo.console.databasemanager.wizard;
+
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.MalformedURLException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Properties;
+import java.util.Random;
+import java.util.Set;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.apache.geronimo.kernel.repository.FileWriteMonitor;
+import org.apache.geronimo.kernel.repository.WriteableRepository;
+
+/**
+ * A utility that handles listing and downloading available JDBC driver JARs.
+ * It can handle straight JARs and also JARs in ZIP files.
+ *
+ * @version $Rev$ $Date$
+ */
+public class DriverDownloader {
+    private final static Log log = LogFactory.getLog(DriverDownloader.class);
+    Random random;
+
+    public Properties readDriverFile(URL url) {
+        try {
+            InputStream in = url.openStream();
+            Properties props = new Properties();
+            props.load(in);
+            in.close();
+            return props;
+        } catch (IOException e) {
+            log.error("Unable to download driver properties", e);
+            return null;
+        }
+    }
+
+    public DriverInfo[] loadDriverInfo(URL driverInfoFile) {
+        List list = new ArrayList();
+        Properties props = readDriverFile(driverInfoFile);
+        if(props == null) {
+            return new DriverInfo[0];
+        }
+        Set drivers = new HashSet();
+        for (Iterator it = props.keySet().iterator(); it.hasNext();) {
+            String key = (String) it.next();
+            if(!key.startsWith("driver.")) {
+                continue;
+            }
+            int pos = key.indexOf('.', 7);
+            if(pos > -1) {
+                drivers.add(key.substring(7, pos));
+            }
+        }
+        List urls = new ArrayList();
+        for (Iterator it = drivers.iterator(); it.hasNext();) {
+            String driver = (String) it.next();
+            String name = props.getProperty("driver."+driver+".name");
+            String repository = props.getProperty("driver."+driver+".repository");
+            String unzip = props.getProperty("driver."+driver+".unzip");
+            urls.clear();
+            int index = 1;
+            while(true) {
+                String url = props.getProperty("driver."+driver+".url."+index);
+                if(url != null) {
+                    ++index;
+                    try {
+                        urls.add(new URL(url));
+                    } catch (MalformedURLException e) {
+                        log.error("Unable to process URL from driver list", e);
+                    }
+                } else {
+                    break;
+                }
+            }
+            if(name != null && repository != null && urls.size() > 0) {
+                DriverInfo info = new DriverInfo(name, repository);
+                info.setUnzipPath(unzip);
+                info.setUrls((URL[]) urls.toArray(new URL[urls.size()]));
+                list.add(info);
+            }
+        }
+        Collections.sort(list);
+        return (DriverInfo[]) list.toArray(new DriverInfo[list.size()]);
+    }
+
+    /**
+     * Downloads a driver and loads it into the local repository.
+     */
+    public void loadDriver(WriteableRepository repo, DriverInfo driver, FileWriteMonitor monitor) throws IOException {
+        try {
+            int urlIndex = 0;
+            if(driver.urls.length > 1) {
+                if(random == null) {
+                    random = new Random();
+                }
+                urlIndex = random.nextInt(driver.urls.length);
+            }
+            URL url = driver.urls[urlIndex];
+            InputStream in;
+            String uri = driver.getRepositoryURI();
+            if(driver.unzipPath != null) {
+                byte[] buf = new byte[1024];
+                int size;
+                int total = 0;
+                int threshold = 10240;
+                InputStream net = url.openStream();
+                JarFile jar = null;
+                File download = null;
+                try {
+                    download = File.createTempFile("geronimo-driver-download", ".zip");
+                    OutputStream out = new BufferedOutputStream(new FileOutputStream(download));
+                    if(monitor != null) {
+                        monitor.writeStarted("Download driver archive to "+download);
+                    }
+                    try {
+                        while((size = net.read(buf)) > -1) {
+                            out.write(buf, 0, size);
+                            if(monitor != null) {
+                                total += size;
+                                if(total > threshold) {
+                                    monitor.writeProgress(total);
+                                    threshold += 10240;
+                                }
+                            }
+                        }
+                        out.flush();
+                        out.close();
+                    } finally {
+                        if(monitor != null) {
+                            monitor.writeComplete(total);
+                        }
+                    }
+                    jar = new JarFile(download);
+                    JarEntry entry = jar.getJarEntry(driver.unzipPath);
+                    if(entry == null) {
+                        log.error("Cannot extract driver JAR "+driver.unzipPath+" from download file "+url);
+                    } else {
+                        in = jar.getInputStream(entry);
+                        repo.copyToRepository(in, new URI(uri), monitor);
+                    }
+                } finally {
+                    if(jar != null) try{jar.close();}catch(IOException e) {log.error("Unable to close JAR file", e);}
+                    if(download != null) {download.delete();}
+                }
+            } else {
+                in = url.openStream();
+                repo.copyToRepository(in, new URI(uri), monitor);
+            }
+        } catch (URISyntaxException e) {
+            throw new IOException("Unable to save to repository URI: "+e.getMessage());
+        }
+    }
+
+//    public static void main(String[] args) {
+//        Random random = new Random();
+//        DriverDownloader test = new DriverDownloader();
+//        try {
+//            DriverInfo[] all = test.loadDriverInfo(new URL("file:///Users/ammulder/driver-downloads.properties"));
+//            org.apache.geronimo.system.serverinfo.ServerInfo info = new org.apache.geronimo.system.serverinfo.BasicServerInfo("/Users/ammulder");
+//            org.apache.geronimo.system.repository.FileSystemRepository repo = new org.apache.geronimo.system.repository.FileSystemRepository(new URI("temp/"), info);
+//            repo.doStart();
+//            test.loadDriver(repo, all[random.nextInt(all.length)], new FileWriteMonitor() {
+//                public void writeStarted(String description) {
+//                    System.out.println("Writing "+description);
+//                }
+//
+//                public void writeProgress(int bytes) {
+//                    System.out.print("\r"+(bytes/1024)+"kB complete");
+//                    System.out.flush();
+//                }
+//
+//                public void writeComplete(int bytes) {
+//                    System.out.println();
+//                    System.out.println("Finished writing: "+bytes+"b");
+//                }
+//            });
+//        } catch (Exception e) {
+//            e.printStackTrace();
+//        }
+//    }
+
+    public static class DriverInfo implements Comparable {
+        private String name;
+        private String repositoryURI;
+        private String unzipPath;
+        private URL[] urls;
+
+        public DriverInfo(String name, String repositoryURI) {
+            this.name = name;
+            this.repositoryURI = repositoryURI;
+        }
+
+        public String getName() {
+            return name;
+        }
+
+        public void setName(String name) {
+            this.name = name;
+        }
+
+        public String getRepositoryURI() {
+            return repositoryURI;
+        }
+
+        public void setRepositoryURI(String repositoryURI) {
+            this.repositoryURI = repositoryURI;
+        }
+
+        public String getUnzipPath() {
+            return unzipPath;
+        }
+
+        public void setUnzipPath(String unzipPath) {
+            this.unzipPath = unzipPath;
+        }
+
+        public URL[] getUrls() {
+            return urls;
+        }
+
+        public void setUrls(URL[] urls) {
+            this.urls = urls;
+        }
+
+        public int compareTo(Object o) {
+            return name.compareTo(((DriverInfo)o).name);
+        }
+    }
+}

Propchange: geronimo/trunk/applications/console/console-standard/src/java/org/apache/geronimo/console/databasemanager/wizard/DriverDownloader.java
------------------------------------------------------------------------------
    svn:eol-style = native

Propchange: geronimo/trunk/applications/console/console-standard/src/java/org/apache/geronimo/console/databasemanager/wizard/DriverDownloader.java
------------------------------------------------------------------------------
    svn:keywords = Rev Date

Propchange: geronimo/trunk/applications/console/console-standard/src/java/org/apache/geronimo/console/databasemanager/wizard/DriverDownloader.java
------------------------------------------------------------------------------
    svn:mime-type = text/plain



Mime
View raw message