Package weka.core

Source Code of weka.core.WekaPackageManager

/*
*    This program is free software; you can redistribute it and/or modify
*    it under the terms of the GNU General Public License as published by
*    the Free Software Foundation; either version 2 of the License, or
*    (at your option) any later version.
*
*    This program is distributed in the hope that it will be useful,
*    but WITHOUT ANY WARRANTY; without even the implied warranty of
*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*    GNU General Public License for more details.
*
*    You should have received a copy of the GNU General Public License
*    along with this program; if not, write to the Free Software
*    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

/*
*    WekaPackageManager.java
*    Copyright (C) 2009 University of Waikato, Hamilton, New Zealand
*/

package weka.core;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URL;
import java.net.URLConnection;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;

import org.pentaho.packageManagement.DefaultPackageManager;
import org.pentaho.packageManagement.Dependency;
import org.pentaho.packageManagement.Package;
import org.pentaho.packageManagement.PackageConstraint;
import org.pentaho.packageManagement.PackageManager;

import weka.core.converters.ConverterUtils;
import weka.gui.GenericObjectEditor;
import weka.gui.GenericPropertiesCreator;
import weka.gui.beans.KnowledgeFlowApp;
import weka.gui.explorer.ExplorerDefaults;

public class WekaPackageManager {
 
  private static String WEKAFILES_DIR_NAME = "wekafiles";
  public static File WEKA_HOME = new File(System.getProperty("user.home")
      + File.separator + WEKAFILES_DIR_NAME);
  public static File PACKAGES_DIR = new File(System.getProperty("user.home")
      + File.separator + WEKAFILES_DIR_NAME + File.separator + "packages");
 
  private static String PROPERTIES_DIR_NAME = "props";
  public static File PROPERTIES_DIR = new File(WEKA_HOME.toString()
      + File.separator + PROPERTIES_DIR_NAME);
 
  private static PackageManager PACKAGE_MANAGER = PackageManager.create();
  private static URL REP_URL;
  private static URL CACHE_URL;
  private static boolean INITIAL_CACHE_BUILD_NEEDED = false;
 
  static {
    establishWekaHome();
  }
 
  protected static boolean m_wekaHomeEstablished;
  protected static boolean m_packagesLoaded;
 
  protected static boolean establishWekaHome() {
    if (m_wekaHomeEstablished) {
      return true;
    }
    // look to see if WEKA_HOME has been defined as an environment
    // variable
    Environment env = Environment.getSystemWide();
    String wh = env.getVariableValue("WEKA_HOME");
    if (wh != null) {
      WEKA_HOME = new File(wh);
      PACKAGES_DIR = new File(wh + File.separator + "packages");
    } else {     
      env.addVariableSystemWide("WEKA_HOME", WEKA_HOME.toString());
    }
   
    boolean ok = true;
    if (!WEKA_HOME.exists()) {
      // create it for the user
      if (!WEKA_HOME.mkdir()) {
        System.err.println("Unable to create WEKA_HOME ("
            + WEKA_HOME.getAbsolutePath() + ")");
        ok = false;
      }
    }
   
    if (!PACKAGES_DIR.exists()) {
      // create the packages dir
      if (!PACKAGES_DIR.mkdir()) {
        System.err.println("Unable to create packages directory ("
            + PACKAGES_DIR.getAbsolutePath() + ")");
        ok = false;
      }
    }
   
    m_wekaHomeEstablished = ok;
    PACKAGE_MANAGER.setPackageHome(PACKAGES_DIR);
    try {
      String repURL = env.getVariableValue("weka.core.wekaPackageRepositoryURL");
      if (repURL == null || repURL.length() == 0) {
        // See if there is a URL named in $WEKA_HOME/props/PackageRepository.props
        File repPropsFile = new File(PROPERTIES_DIR.toString() + File.separator
            + "PackageRepository.props");
       
       
        if (repPropsFile.exists()) {
          Properties repProps = new Properties();
          repProps.load(new FileInputStream(repPropsFile));
          repURL = repProps.getProperty("weka.core.wekaPackageRepositoryURL");
        }
      }
     
      if (repURL == null || repURL.length() == 0) {
        repURL = "http://weka.sourceforge.net/packageMetaData";
      } else {
        System.err.println("weka.core.WekaPackageRepositoryURL = " + repURL);
      }
     
      REP_URL = new URL(repURL);
      PACKAGE_MANAGER.setPackageRepositoryURL(REP_URL);
    } catch (MalformedURLException ex) {
      ex.printStackTrace();
    } catch (IOException ex) {
      ex.printStackTrace();
    }
   
    PACKAGE_MANAGER.setBaseSystemName("weka");
    PACKAGE_MANAGER.setBaseSystemVersion(weka.core.Version.VERSION);
   
    // Now check the cache and establish it if necessary
    File cacheDir = new File(WEKA_HOME.toString() + File.separator
        + "repCache");
    try {
      String tempCacheString = "file://" + cacheDir.toString();
      // sanitize URI and fix slashes (for Windows)
      tempCacheString = tempCacheString.replace(" ", "%20");
      tempCacheString = tempCacheString.replace('\\', '/');
      if (tempCacheString.startsWith("file://") && !tempCacheString.startsWith("file:///")) {
        tempCacheString = tempCacheString.substring(7);
        tempCacheString = "file:///" + tempCacheString;
      }
      URI tempURI = new URI(tempCacheString);
//      System.err.println(" -- " + tempURI.toString());
      CACHE_URL = tempURI.toURL();
    } catch (Exception e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
    if (!cacheDir.exists()) {
      if (!cacheDir.mkdir()) {
        System.err.println("Unable to create repository cache directory ("
            + cacheDir.getAbsolutePath() + ")");
        CACHE_URL = null;
      } else {
        // refreshCache();
        INITIAL_CACHE_BUILD_NEEDED = true;
      }
    }
   
    return ok;
  }
 
  public static void removeExplorerProps(String installedPackageName) {
    try {
      Properties expProps = new Properties();
      String explorerProps = getPackageHome().getAbsolutePath()
        + File.separator + installedPackageName + File.separator
        + "Explorer.props";
      BufferedInputStream bi = new BufferedInputStream(new FileInputStream(explorerProps));
      expProps.load(bi);
      bi.close();
      bi = null;
      Set keys = expProps.keySet();
      Iterator keysI = keys.iterator();
      while (keysI.hasNext()) {
        String key = (String)keysI.next();
        if (!key.endsWith("Policy")) {
          // See if this key is in the Explorer props
          String existingVal = ExplorerDefaults.get(key, "");
          String toRemove = expProps.getProperty(key);
          if (existingVal.length() > 0) {
            // cover the case when the value to remove is at the start
            // or middle of a list
            existingVal = existingVal.replace(toRemove + ",", "");
           
            // the case when it's at the end
            existingVal = existingVal.replace("," + toRemove, "");
            ExplorerDefaults.set(key, existingVal);
          }
        }
      }
    } catch (Exception ex) {     
    }
  }
 
  protected static void processGenericPropertiesCreatorProps(File propsFile) {
    try {
      Properties expProps = new Properties();
      BufferedInputStream bi = new BufferedInputStream(new FileInputStream(propsFile));
      expProps.load(bi);
      bi.close();
      bi = null;
      Properties GPCInputProps = GenericPropertiesCreator.getGlobalInputProperties();
     
      Set keys = expProps.keySet();
      Iterator keysI = keys.iterator();
      while (keysI.hasNext()) {
        String key = (String)keysI.next();
        // see if this key is in the GPC input props
        String existingVal = GPCInputProps.getProperty(key, "");
        if (existingVal.length() > 0) {
          // append
          String newVal = expProps.getProperty(key);
          // only append if this value is not already there!!
          if (existingVal.indexOf(newVal) < 0) {
            newVal = existingVal + "," + newVal;
            GPCInputProps.put(key, newVal);
          }
        } else {
          // simply add this new key/value combo
          String newVal = expProps.getProperty(key);
          GPCInputProps.put(key, newVal);
        }
      }
    } catch (Exception ex) {
      // ignore
    }
  }
 
  protected static void processExplorerProps(File propsFile) {
    try {
      Properties expProps = new Properties();
      BufferedInputStream bi = new BufferedInputStream(new FileInputStream(propsFile));
      expProps.load(bi);
      bi.close();
      bi = null;
      Set keys = expProps.keySet();
      Iterator keysI = keys.iterator();
      while (keysI.hasNext()) {
        String key = (String)keysI.next();
        if (!key.endsWith("Policy")) {
          // See if this key is in the Explorer props
          String existingVal = ExplorerDefaults.get(key, "");
          if (existingVal.length() > 0) {
            // get the replacement policy (if any)
            String replacePolicy = expProps.getProperty(key + "Policy");
            if (replacePolicy != null && replacePolicy.length() > 0) {
              if (replacePolicy.equalsIgnoreCase("replace")) {
                String newVal = expProps.getProperty(key);
                ExplorerDefaults.set(key, newVal);               
              } else {
                // default to append               
                String newVal = expProps.getProperty(key);
               
                // only append if this value is not already there!!
                if (existingVal.indexOf(newVal) < 0) {
                  newVal = existingVal + "," + newVal;
                  ExplorerDefaults.set(key, newVal);
                }
              }
            } else {
              // default to append
              String newVal = expProps.getProperty(key);
              // only append if this value is not already there!!
              if (existingVal.indexOf(newVal) < 0) {
                newVal = existingVal + "," + newVal;
                ExplorerDefaults.set(key, newVal);
              }
            }
          } else {
            // simply add this new key/value combo
            String newVal = expProps.getProperty(key);
            ExplorerDefaults.set(key, newVal);
          }
        }
      }
    } catch (Exception ex) {
      // ignore
    }
  }
 
  protected static void processGUIEditorsProps(File propsFile) {
    GenericObjectEditor.registerEditors();
    try {
      Properties editorProps = new Properties();
      BufferedInputStream bi = new BufferedInputStream(new FileInputStream(propsFile));
      editorProps.load(bi);
      bi.close();
      bi = null;
     
      Enumeration enm = editorProps.propertyNames();
      while (enm.hasMoreElements()) {
        String name = enm.nextElement().toString();
        String value = editorProps.getProperty(name, "");
        System.err.println("Registering " + name + " " +value);
        GenericObjectEditor.registerEditor(name, value);
      }
     
    } catch (Exception ex) {
      // ignore
    }
  }   
 
  protected static void loadPackageDirectory(File directory, boolean verbose) throws Exception {
    File[] contents = directory.listFiles();
   
    // make sure that jar files and lib directory get processed first
    for (int i = 0; i < contents.length; i++) {
      if (contents[i].isFile() &&
          contents[i].getPath().endsWith(".jar")) {
        if (verbose) {
          System.out.println("[Weka] loading " + contents[i].getPath());
        }
        ClassloaderUtil.addFile(contents[i].getPath());
      } else if (contents[i].isDirectory() &&
          contents[i].getName().equalsIgnoreCase("lib")) {
        // add any jar files in the lib directory to the classpath
        loadPackageDirectory(contents[i], verbose);
      }
    }
   
    // now any auxilliary files
    for (int i = 0; i < contents.length; i++) {
      if (contents[i].isFile() && contents[i].getPath().endsWith("Beans.props")) {
        // KnowledgeFlow plugin -- add the Beans.props file to the list of
        // bean plugin props

        KnowledgeFlowApp.addToPluginBeanProps(contents[i]);
        KnowledgeFlowApp.disposeSingleton();

      } else if (contents[i].isFile() &&
          contents[i].getPath().endsWith("Explorer.props")) {
        // Explorer tabs plugin
        // process the keys in the properties file and append/add values
        processExplorerProps(contents[i]);
      } else if (contents[i].isFile() &&
          contents[i].getPath().endsWith("GUIEditors.props")) {
        // Editor for a particular component
        processGUIEditorsProps(contents[i]);
      } else if (contents[i].isFile() &&
          contents[i].getPath().endsWith("GenericPropertiesCreator.props")) {
        processGenericPropertiesCreatorProps(contents[i]);
      }
        /* else if (contents[i].isFile() &&
          contents[i].getPath().endsWith(".jar")) {
        if (verbose) {
          System.out.println("[Weka] loading " + contents[i].getPath());
        }
        ClassloaderUtil.addFile(contents[i].getPath());
      } else if (contents[i].isDirectory() &&
          contents[i].getName().equalsIgnoreCase("lib")) {
        // add any jar files in the lib directory to the classpath
        loadPackageDirectory(contents[i], verbose);
      } */
    }
  } 
 
  public static boolean loadCheck(Package toLoad, File packageRoot,
      PrintStream... progress) {
   
    // first check against the base version of the system
    boolean load;
    try {
      load = toLoad.isCompatibleBaseSystem();
    } catch (Exception ex) {
      ex.printStackTrace();
      return false;
    }
   
    if (!load) {
      for (PrintStream p : progress) {
        p.println("[Weka] Skipping package " + toLoad.getName()
            + " because it is not compatible with Weka "
            + PACKAGE_MANAGER.getBaseSystemVersion().toString());
      }
      return false;
    }
   
    // first check for missing special files/directories and
    // missing external classes (if any)
   
    if (!(checkForMissingClasses(toLoad, progress) &&
        checkForMissingFiles(toLoad, packageRoot, progress))) {
      return false;
    }
   
    // now check for missing dependencies
    try {
      List<Dependency> missing = toLoad.getMissingDependencies();
      if (missing.size() > 0) {
        for (PrintStream p : progress) {
          p.println("[Weka] " + toLoad.getName() + " can't be loaded because the following" +
          " packages are missing:");
          for (Dependency d : missing) {
            p.println(d.getTarget());
          }
        }
        return false;
      }
    } catch (Exception ex) {
      ex.printStackTrace();
      return false;
    }
   
    // now check for buggered dependencies
    try {
      List<Dependency> depends = toLoad.getDependencies();
      for (Dependency d : depends) {
        if (d.getTarget().getPackage().isInstalled()) {         
          if (!loadCheck(d.getTarget().getPackage(), packageRoot, progress)) {
            for (PrintStream p : progress) {
              p.println("[Weka] Can't load " + toLoad.getName() + " because " +
                  d.getTarget() + " can't be loaded.");
            }
            return false;
          }
        }
      }
    } catch (Exception ex) {
      ex.printStackTrace();
      return false;
    }
   
   
    return true;
  }
 
  /**
   * Checks to see if there are any classes that we should try to instantiate
   * before allowing this package to be loaded. This is useful for checking
   * to see if third-party classes are accessible. An example would be
   * Java3D, which has an installer that installs into the JRE/JDK.
   *
   * @param toLoad the package to check
   * @return true if good to go
   */
  public static boolean checkForMissingClasses(Package toLoad,
      PrintStream... progress) {
    boolean result = true;
    Object doNotLoadIfClassNotInstantiable =
      toLoad.getPackageMetaDataElement("DoNotLoadIfClassNotPresent");
   
    if (doNotLoadIfClassNotInstantiable != null &&
        doNotLoadIfClassNotInstantiable.toString().length() > 0) {
     
      StringTokenizer tok = new StringTokenizer(doNotLoadIfClassNotInstantiable.toString(), ",");
      while (tok.hasMoreTokens()) {
        String nextT = tok.nextToken().trim();
        try {
          Class.forName(nextT);
        } catch (Exception ex) {
          for (PrintStream p : progress) {
            p.println("[Weka] " + toLoad.getName() + " can't be loaded because "
                + nextT + " can't be instantiated.");
          }
          result = false;
          break;
        }
      }
    }
   
    if (!result) {
      // grab the message to print to the log (if any)
      Object doNotLoadMessage =
        toLoad.getPackageMetaDataElement("DoNotLoadIfClassNotPresentMessage");
      if (doNotLoadMessage != null && doNotLoadMessage.toString().length() > 0) {
        for (PrintStream p : progress) {
          String dnlM = doNotLoadMessage.toString();
          try {
            dnlM = Environment.getSystemWide().substitute(dnlM);
          } catch (Exception e) {
            // quietly ignore
          }
          p.println("[Weka] " + dnlM);
        }
      }
    }
   
    return result;
  }
 
  /**
   * Checks to see if there are any missing files/directories for a
   * given package. If there are missing files, then the package can't
   * be loaded. An example would be a connector package that, for whatever
   * reason, can't include a necessary third-party jar file in its lib
   * folder, and requires the user to download and install this jar file
   * manually.
   *
   * @param toLoad the package to check
   * @param packageRoot the root directory of the package
   * @return true if good to go
   */
  public static boolean checkForMissingFiles(Package toLoad,
      File packageRoot, PrintStream... progress) {
    boolean result = true;

    Object doNotLoadIfFileMissing =
      toLoad.getPackageMetaDataElement("DoNotLoadIfFileNotPresent");
    String packageRootPath = packageRoot.getPath() + File.separator;
   
    if (doNotLoadIfFileMissing != null &&
        doNotLoadIfFileMissing.toString().length() > 0) {

      StringTokenizer tok = new StringTokenizer(doNotLoadIfFileMissing.toString(), ",");
      while (tok.hasMoreTokens()) {
        String nextT = tok.nextToken().trim();
        File toCheck = new File(packageRootPath + nextT);
        if (!toCheck.exists()) {
          for (PrintStream p : progress) {
            p.println("[Weka] " + toLoad.getName() + " can't be loaded because "
                + toCheck.getPath() + " appears to be missing.");
          }
          result = false;
          break;
        }
      }
    }
   
    if (!result) {
      // grab the message to print to the log (if any)
      Object doNotLoadMessage =
        toLoad.getPackageMetaDataElement("DoNotLoadIfFileNotPresentMessage");
      if (doNotLoadMessage != null && doNotLoadMessage.toString().length() > 0) {
        String dnlM = doNotLoadMessage.toString();
        try {
          dnlM = Environment.getSystemWide().substitute(dnlM);
        } catch (Exception ex) {
          // quietly ignore
        }
        for (PrintStream p : progress) {
          p.println("[Weka] " + dnlM);
        }
      }
    }
   
    return result;
  }
 
  public static synchronized void loadPackages(boolean verbose) {
    loadPackages(verbose, true);
  }
 
  public static synchronized void loadPackages(boolean verbose, boolean refreshGOEProperties) {
    Environment env = Environment.getSystemWide();
    String loadPackages = env.getVariableValue("weka.core.loadPackages");
    if (loadPackages != null && loadPackages.equalsIgnoreCase("false")) {
      return;
    }

    if (m_packagesLoaded) {
      return;
    }
   
    m_packagesLoaded = true;
    if (establishWekaHome()) {
      // try and load any jar files and add to the classpath
      File[] contents = PACKAGES_DIR.listFiles();
      for (int i = 0 ; i < contents.length; i++) {
        if (contents[i].isDirectory()) {
          try {
            Package toLoad = getInstalledPackageInfo(contents[i].getName());
            boolean load;
            // Only perform the check against the current version of Weka if there exists
            // a Description.props file
            if (toLoad != null) {

              load = loadCheck(toLoad, contents[i], System.err);
              /*                // check to see if any of the DoNotLoad keys are present
                load = checkForMissingClasses(toLoad, System.err);

                if (load) {
                  load = checkForMissingFiles(toLoad, contents[i],
                      System.err);
                } */
              if (load) {
                if (verbose) {
                  System.out.println("[Weka] loading package " + contents[i].getName());
                }
                loadPackageDirectory(contents[i], verbose);
              }
            }
          } catch (Exception ex) {
            ex.printStackTrace();
            System.err.println("[Weka] Problem loading package " + contents[i].getName()
                + " skipping...");
          }         
        }
      }
    }
   
    // do we need to regenerate the list of available schemes for
    // the GUIs (this is not necessary when executing stuff from
    // the command line
    if (refreshGOEProperties) {
      refreshGOEProperties();
    }
  }
 
  public static void refreshGOEProperties() {
    ClassDiscovery.clearClassCache();
    GenericPropertiesCreator.regenerateGlobalOutputProperties();
    GenericObjectEditor.determineClasses();
    ConverterUtils.initialize();
    KnowledgeFlowApp.disposeSingleton();
    KnowledgeFlowApp.reInitialize();
  }
 
  public static PackageManager getUnderlyingPackageManager() {
    return PACKAGE_MANAGER;
  }
 
  /**
   * Get the number of packages that are available at the repository.
   *
   * @return the number of packages that are available (or -1 if this
   * can't be determined for some reason.
   */
  public static int numRepositoryPackages() {
    int numPackages = -1;
    try {
      PACKAGE_MANAGER.setPackageRepositoryURL(REP_URL);
      String numPackagesS = PACKAGE_MANAGER.getPackageRepositoryURL().toString()
      + "/numPackages.txt";
      URLConnection conn = null;
      URL connURL = new URL(numPackagesS);

      if (PACKAGE_MANAGER.setProxyAuthentication()) {
        conn = connURL.openConnection(PACKAGE_MANAGER.getProxy());
      } else {
        conn = connURL.openConnection();
      }
     
      conn.setConnectTimeout(30000); // timeout after 30 seconds
     
      BufferedReader bi =
        new BufferedReader(new InputStreamReader(conn.getInputStream()));
     
      String n = bi.readLine();
      try {
        numPackages = Integer.parseInt(n);
      } catch (NumberFormatException ne) {
        System.err.println("[WekaPackageManager] problem parsing number " +
            "of packages from server.");
      }
      bi.close();

    } catch (Exception ex) {
      ex.printStackTrace();
    }
   
    return numPackages;
  }   
 
  /**
   * Just get a list of the package names.
   * This is faster than calling getAllPackages(), especially
   * if fetching from the online repository, since the full meta
   * data for each package doesn't have to be read.
   *
   * @param local true if the local package list in the cache should
   * be read rather than the online repository
   *
   * @return a Map<String, String> of all the package names available either
   * locally or at the repository
   */
  public static Map<String, String> getPackageList(boolean local) {
    Map<String, String> result = new HashMap<String, String>();
   
    try {
    useCacheOrOnlineRepository();
   
    if (!local) {
      PACKAGE_MANAGER.setPackageRepositoryURL(REP_URL);
    }
   
    String packageListS = PACKAGE_MANAGER.getPackageRepositoryURL().toString()
    + "/packageList.txt";
    URLConnection conn = null;
    URL connURL = new URL(packageListS);

    if (PACKAGE_MANAGER.setProxyAuthentication()) {
      conn = connURL.openConnection(PACKAGE_MANAGER.getProxy());
    } else {
      conn = connURL.openConnection();
    }
   
    conn.setConnectTimeout(30000); // timeout after 30 seconds
   
    BufferedReader bi =
      new BufferedReader(new InputStreamReader(conn.getInputStream()));
    String l = null;
    while ((l = bi.readLine()) != null) {
      result.put(l,l);
    }
    bi.close();
   
    } catch (Exception ex) {
      ex.printStackTrace();
      result = null;
    }
   
    return result;
  }
 
  public static Exception establishCacheIfNeeded(PrintStream... progress) {
    Exception problem = null;
    if (INITIAL_CACHE_BUILD_NEEDED) {
      for (PrintStream p : progress) {
        p.println("Caching repository meta data, please wait...");
      }
     
      problem = refreshCache(progress);

      INITIAL_CACHE_BUILD_NEEDED = false;
    }
    return problem;
  }
 
  public static Exception checkForNewPackages(PrintStream... progress) {
    Exception problem = null;
   
    Map<String, String> localPackageNameList = getPackageList(true);
   
    if (localPackageNameList == null) {
      // quietly return and see if we can continue anyway
      return null;
    }
   
    Map<String, String> repositoryPackageNameList = getPackageList(false);
   
    if (repositoryPackageNameList == null) {
      // quietly return and see if we can continue anyway
      return null;
    }
   
    if (repositoryPackageNameList.keySet().size() !=
        localPackageNameList.keySet().size()) {
      // package(s) have disappeared from the repository.
      // Force a cache refresh...
      if (repositoryPackageNameList.keySet().size() <
          localPackageNameList.keySet().size()) {
        for (PrintStream p : progress) {
          p.println("Some packages no longer exist at the repository. " +
          "Refreshing cache...");
        }
      } else {
        for (PrintStream p : progress) {
          p.println("There are new packages at the repository. " +
          "Refreshing cache...");
        }
      }
      problem = refreshCache(progress);
    }     
   
    return problem;
  }
 
  public static Exception refreshCache(PrintStream... progress) {
    Exception problem = null;
    if (CACHE_URL == null) {
      return null;
    }       
   
    PACKAGE_MANAGER.setPackageRepositoryURL(REP_URL);
    String cacheDir = WEKA_HOME.toString() + File.separator
    + "repCache";
    try {
      for (PrintStream p : progress) {
        p.println("Refresh in progress. Please wait...");
      }
      byte[] zip = PACKAGE_MANAGER.getRepositoryPackageMetaDataOnlyAsZip(progress);

      /*File tempF = new File(WEKA_HOME.toString() + File.separator
          + "repCache/rep.zip");
      BufferedOutputStream bos =
        new BufferedOutputStream(new FileOutputStream(tempF));
      bos.write(zip);
      bos.close();*/
     
      ZipInputStream zis = new ZipInputStream(new ByteArrayInputStream(zip));
      ZipEntry ze;
      final byte[] buff = new byte[1024];
      while ((ze = zis.getNextEntry()) != null) {
//        System.out.println("Cache: inflating " + ze.getName());
        if (ze.isDirectory()) {
          new File(cacheDir, ze.getName()).mkdir();
          continue;
        }
        BufferedOutputStream bo =
          new BufferedOutputStream(new FileOutputStream(new File(cacheDir, ze.getName())));
        while (true) {
          int amountRead = zis.read(buff);
          if (amountRead == -1) {
            break;
          }
          // write the data here
          bo.write(buff, 0, amountRead);
        }
        bo.close();
      }
    } catch (Exception e) {
      e.printStackTrace();
     
      // OK, we have a problem with the repository cache - use
      // the repository itself instead and delete repCache
      CACHE_URL = null;
      try {
        DefaultPackageManager.deleteDir(new File(cacheDir), System.out);
      } catch (Exception e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
      }
     
      return e;
    }
       
    return problem;
  }
 
  public static boolean installedPackageResourceExists(String packageName,
      String resourceName) {
   
    String fullResourcePath = getPackageHome().toString()
      + File.separator + packageName + File.separator + resourceName;
   
    return new File(fullResourcePath).exists();
  }
 
  private static void useCacheOrOnlineRepository() {
    if (CACHE_URL != null) {
      PACKAGE_MANAGER.setPackageRepositoryURL(CACHE_URL);
    } else {
      PACKAGE_MANAGER.setPackageRepositoryURL(REP_URL);
    }
  }
 
  public static File getPackageHome() {
    return PACKAGE_MANAGER.getPackageHome();
  }
 
  /**
   * Find the most recent version of the package encapsulated in the
   * supplied PackageConstraint argument that satisfies the constraint
   *
   * @param toCheck the PackageConstraint containing the package in question
   * @return the most recent version of the package satisfying the constraint
   * @throws Exception if a version can't be found that satisfies the constraint
   * or an error occurs while communicating with the respository
   */
  public static Package mostRecentVersionWithRespectToConstraint(PackageConstraint toCheck)
    throws Exception {
    Package target = toCheck.getPackage();
    Package result = null;
   

    List<Object> availableVersions =
      PACKAGE_MANAGER.getRepositoryPackageVersions(target.getName());

    // version numbers will be in descending sorted order from the repository
    // we want the most recent version that meets the target constraint
    for (Object version : availableVersions) {
      Package candidate = PACKAGE_MANAGER.getRepositoryPackageInfo(target.getName(), version);
      if (toCheck.checkConstraint(candidate)) {
        /*System.out.println("**** Most recent version of " + target.getName()
            + "that meets the constraint " + toCheck.toString() + " is "
            + candidate.toString()); */
        result = candidate;
        break;
      }
    }
   
    if (result == null) {
      throw new Exception("[WekaPackageManager] unable to find a version of " +
          "package " + target.getName() + " that meets constraint " +
          toCheck.toString());
    }

    return result;
  }
 
  public static void installPackages(List<Package> toInstall,
      PrintStream... progress) throws Exception {
   
    useCacheOrOnlineRepository();   
    PACKAGE_MANAGER.installPackages(toInstall, progress);
   
    for (Package p : toInstall) {     
     
      String packageName = p.getName();
      File packageDir = new File(PACKAGE_MANAGER.getPackageHome().toString() + File.separator
          + packageName);
     
      boolean loadIt = loadCheck(p, packageDir, progress);
     
      if (loadIt) {
        loadPackageDirectory(packageDir, false);
      }
    }
  }
   
  public static List<Object> getRepositoryPackageVersions(String packageName) throws Exception {
    useCacheOrOnlineRepository();   
    return PACKAGE_MANAGER.getRepositoryPackageVersions(packageName);
  }
 
  public static URL getPackageRepositoryURL() {
    useCacheOrOnlineRepository();   
    return PACKAGE_MANAGER.getPackageRepositoryURL();
  }
 
  public static List<Package> getAllPackages() throws Exception {
    useCacheOrOnlineRepository();   
    return PACKAGE_MANAGER.getAllPackages();
  }
 
  public static List<Package> getAvailablePackages() throws Exception {
    useCacheOrOnlineRepository();   
    return PACKAGE_MANAGER.getAvailablePackages();
  }
 
  public static List<Package> getInstalledPackages() throws Exception {
    useCacheOrOnlineRepository();   
    return PACKAGE_MANAGER.getInstalledPackages();
  }
 
  public static List<Dependency> getAllDependenciesForPackage(Package target,
      Map<String, List<Dependency>> conflicts) throws Exception {
    useCacheOrOnlineRepository();   
    return PACKAGE_MANAGER.getAllDependenciesForPackage(target, conflicts);
  }
   
  public static Package getPackageArchiveInfo(String packageArchivePath) throws Exception {
    useCacheOrOnlineRepository();   
    return PACKAGE_MANAGER.getPackageArchiveInfo(packageArchivePath);
  }
 
  public static Package getInstalledPackageInfo(String packageName) throws Exception {
    useCacheOrOnlineRepository();   
    return PACKAGE_MANAGER.getInstalledPackageInfo(packageName);
  }
 
  public static Package getRepositoryPackageInfo(String packageName) throws Exception {
    useCacheOrOnlineRepository();   
    return PACKAGE_MANAGER.getRepositoryPackageInfo(packageName);
  }
 
  public static Package getRepositoryPackageInfo(String packageName, String version)
    throws Exception {
    useCacheOrOnlineRepository();   
    return PACKAGE_MANAGER.getRepositoryPackageInfo(packageName, version);
  }
 
  public static void installPackageFromRepository(String packageName,
      String version, PrintStream... progress)
    throws Exception {   
    useCacheOrOnlineRepository();
    Package toLoad = getRepositoryPackageInfo(packageName);
   
    Object specialInstallMessage =
      toLoad.getPackageMetaDataElement("MessageToDisplayOnInstallation");
    if (specialInstallMessage != null &&
        specialInstallMessage.toString().length() > 0) {
      String siM = specialInstallMessage.toString();
      try {
        siM = Environment.getSystemWide().substitute(siM);
      } catch (Exception ex) {
        // quietly ignore
      }
      String message = "**** Special installation message ****\n"
        + siM
            + "\n**** Special installation message ****";
      for (PrintStream p : progress) {
        p.println(message);
      }
    }
   
    PACKAGE_MANAGER.installPackageFromRepository(packageName, version, progress);
    File packageDir = new File(PACKAGE_MANAGER.getPackageHome().toString() + File.separator
        + packageName);
   
    boolean loadIt = checkForMissingClasses(toLoad, progress);
    if (loadIt) {
      File packageRoot =
        new File(PACKAGE_MANAGER.getPackageHome() + File.separator
            + packageName);
      loadIt = checkForMissingFiles(toLoad, packageRoot, progress);
      if (loadIt) {
        loadPackageDirectory(packageDir, false);
      }
    }
  }
 
  public static String installPackageFromArchive(String packageArchivePath,
      PrintStream... progress) throws Exception {
    useCacheOrOnlineRepository();   
    Package toInstall = PACKAGE_MANAGER.getPackageArchiveInfo(packageArchivePath);
   
    Object specialInstallMessage =
      toInstall.getPackageMetaDataElement("MessageToDisplayOnInstallation");
    if (specialInstallMessage != null &&
        specialInstallMessage.toString().length() > 0) {
      String siM = specialInstallMessage.toString();
      try {
        siM = Environment.getSystemWide().substitute(siM);
      } catch (Exception ex) {
        // quietly ignore
      }
      String message = "**** Special installation message ****\n"
        + siM
            + "\n**** Special installation message ****";
      for (PrintStream p : progress) {
        p.println(message);
      }
    }
   
    PACKAGE_MANAGER.installPackageFromArchive(packageArchivePath, progress);
   
    boolean loadIt = checkForMissingClasses(toInstall, progress);
    if (loadIt) {
      File packageRoot =
        new File(PACKAGE_MANAGER.getPackageHome() + File.separator
            + toInstall.getName());
      loadIt = checkForMissingFiles(toInstall, packageRoot, progress);
      if (loadIt) {
        loadPackageDirectory(packageRoot, false);
      }
    }
   
    return toInstall.getName();
  }
 
  public static String installPackageFromURL(URL packageURL, PrintStream... progress) throws Exception {
    useCacheOrOnlineRepository();   
    String packageName = PACKAGE_MANAGER.installPackageFromURL(packageURL, progress);
   
    Package installed = PACKAGE_MANAGER.getInstalledPackageInfo(packageName);
   
    Object specialInstallMessage =
      installed.getPackageMetaDataElement("MessageToDisplayOnInstallation");
    if (specialInstallMessage != null &&
        specialInstallMessage.toString().length() > 0) {
      String message = "**** Special installation message ****\n"
        + specialInstallMessage.toString()
            + "\n**** Special installation message ****";
      for (PrintStream p : progress) {
        p.println(message);
      }
    }
   
    boolean loadIt = checkForMissingClasses(installed, progress);
    if (loadIt) {
      File packageRoot =
        new File(PACKAGE_MANAGER.getPackageHome() + File.separator
            + installed.getName());
      loadIt = checkForMissingFiles(installed, packageRoot, progress);
      if (loadIt) {
        loadPackageDirectory(packageRoot, false);
      }
    }
    return packageName;
  }
 
  public static void uninstallPackage(String packageName, boolean updateKnowledgeFlow,
      PrintStream... progress)
    throws Exception {
   
    // check to see if this is a KnowledgeFlow package (presence of Beans.props file)
    if (updateKnowledgeFlow) {
      File packageToDel = new File(PACKAGE_MANAGER.getPackageHome().toString() + File.separator
          + packageName);
      if (packageToDel.exists() && packageToDel.isDirectory()) {
        File[] contents = packageToDel.listFiles();
        for (int i = 0; i < contents.length; i++) {
          if (contents[i].isFile() && contents[i].getPath().endsWith("Beans.props")) {
            // KnowledgeFlow plugin -- remove this properties file from the list of
            // bean plugin props

            KnowledgeFlowApp.removeFromPluginBeanProps(contents[i]);
            KnowledgeFlowApp.disposeSingleton();
            break;
          }
        }
      }
    }
   
    PACKAGE_MANAGER.uninstallPackage(packageName, progress);
  }
 
  private static void printPackageInfo(Map<?,?> packageProps) {
    Set<?> keys = packageProps.keySet();
    Iterator<?> i = keys.iterator();
   
    while (i.hasNext()) {
      Object key = i.next();
      Object value = packageProps.get(key);
      System.out.println(Utils.padLeft(key.toString(), 11) + ":\t" + value.toString());
    }
  }
   
  protected static void printPackageArchiveInfo(String packagePath) throws Exception {
    Map<?,?> packageProps = getPackageArchiveInfo(packagePath).getPackageMetaData();
    printPackageInfo(packageProps);
  }
 
  protected static void printInstalledPackageInfo(String packageName) throws Exception {
    Map<?,?> packageProps = getInstalledPackageInfo(packageName).getPackageMetaData();
    printPackageInfo(packageProps);
  }
 
  protected static void printRepositoryPackageInfo(String packageName,
      String version) throws Exception {
    Map<?,?> packageProps = getRepositoryPackageInfo(packageName, version).getPackageMetaData();
    printPackageInfo(packageProps);
  }
 
  private static String queryUser() {
    java.io.BufferedReader br =
      new java.io.BufferedReader(new java.io.InputStreamReader(System.in));
   
    String result = null;
    try {
      result = br.readLine();
    } catch (java.io.IOException ex) {
      // ignore
    }
   
    return result;
  }
 
  private static void removeInstalledPackage(String packageName, boolean force,
      PrintStream... progress) throws Exception {
   
    List<Package> compromised = new ArrayList<Package>();

    // Now check to see which other installed packages depend on this one
    List<Package> installedPackages = null;
    if (!force) {
      installedPackages = getInstalledPackages();
      for (Package p : installedPackages) {
        List<Dependency> tempDeps = p.getDependencies();

        for (Dependency d : tempDeps) {
          if (d.getTarget().getPackage().getName().equals(packageName)) {
            // add this installed package to the list
            compromised.add(p);
            break;
          }
        }
      }

      if (compromised.size() > 0) {
        System.out.println("The following installed packages depend on "
            + packageName + " :\n");
        for (Package p : compromised) {
          System.out.println("\t" + p.getName());
        }

        System.out.println("\nDo you wish to proceed [y/n]?");
        String response = queryUser();
        if (response != null && (response.equalsIgnoreCase("n") ||
            response.equalsIgnoreCase("no"))) {
          return; // bail out here
        }
      }
    }
   
    if (force) {
      System.out.println("Forced uninstall.");
    }
  
   compromised = null;
   installedPackages = null;
  
   uninstallPackage(packageName, false, progress);
  }
 
  private static void installPackageFromRepository(String packageName, String version,
      boolean force) throws Exception {
       
    Package toInstall = null;
    try {
      toInstall = getRepositoryPackageInfo(packageName, version);
    } catch (Exception ex) {
      System.err.println("[WekaPackageManager] Package " + packageName + " at version " + version
          + " doesn't seem to exist!");
      //System.exit(1);
      return;
    }
    // First check to see if this package is compatible with the base system
   
    if (!force) {
      boolean ok = toInstall.isCompatibleBaseSystem();
     
      if (!ok) {
        List<Dependency> baseSysDep = toInstall.getBaseSystemDependency();
        StringBuffer depList = new StringBuffer();
        for (Dependency bd : baseSysDep) {
          depList.append(bd.getTarget().toString() + " ");
        }
        System.err.println("Can't install package " + packageName
            + " because it requires " + depList.toString());
        return;
      }     
     
      // true if this package is already installed. In which case we need to check
      // if changing this package will impact other already installed packages
      boolean upOrDowngrading = false;
      if (toInstall.isInstalled()) {
        Package installedVersion = getInstalledPackageInfo(packageName);
        if (!toInstall.equals(installedVersion)) {

          System.out.println("Package " + packageName + "[" + installedVersion
              + "] is already installed. Replace with " + toInstall +" [y/n]?");
         
          String response = queryUser();
          if (response != null && (response.equalsIgnoreCase("n") ||
              response.equalsIgnoreCase("no"))) {
            return; // bail out here
          }
          upOrDowngrading = true;
        } else {
          System.out.println("Package " + packageName + "[" + installedVersion
              + "] is already installed. Install again [y/n]?");
          String response = queryUser();
          if (response != null && (response.equalsIgnoreCase("n") ||
              response.equalsIgnoreCase("no"))) {
            return; // bail out here
          }
        }
      }

      // Now get a full list of dependencies for this package and
      // check for any conflicts
      Map<String, List<Dependency>> conflicts = new HashMap<String, List<Dependency>>();
      List<Dependency> dependencies = getAllDependenciesForPackage(toInstall, conflicts);

      if (conflicts.size() > 0) {
        System.err.println("Package " + packageName + " requires the following packages:\n");
        Iterator<Dependency> depI = dependencies.iterator();
        while (depI.hasNext()) {
          Dependency d = depI.next();
          System.err.println("\t" + d);
        }
       
        System.err.println("\nThere are conflicting dependencies:\n");
        Set<String> pNames = conflicts.keySet();
        Iterator<String> pNameI = pNames.iterator();
        while (pNameI.hasNext()) {
          String pName = pNameI.next();
          System.err.println("Conflicts for " + pName);
          List<Dependency> confsForPackage = conflicts.get(pName);
          Iterator<Dependency> confs = confsForPackage.iterator();
          while (confs.hasNext()) {
            Dependency problem = confs.next();
            System.err.println("\t" + problem);
          }
        }
       
        System.err.println("Unable to continue with installation.");
        return; // bail out here.
      }
     
      // Next check all dependencies against what is installed and
      // inform the user about which installed packages will be altered. Also
      // build the list of only those packages that need to be installed or
      // upgraded (excluding those that are already installed and are OK).
      List<PackageConstraint> needsUpgrade = new ArrayList<PackageConstraint>();
      List<Package> finalListToInstall = new ArrayList<Package>();
     
      Iterator<Dependency> depI = dependencies.iterator();
      while (depI.hasNext()) {
        Dependency toCheck = depI.next();
        if (toCheck.getTarget().getPackage().isInstalled()) {
          String toCheckName =
            toCheck.getTarget().getPackage().
            getPackageMetaDataElement("PackageName").toString();
          Package installedVersion = PACKAGE_MANAGER.getInstalledPackageInfo(toCheckName);
          if (!toCheck.getTarget().checkConstraint(installedVersion)) {
            needsUpgrade.add(toCheck.getTarget());
            Package mostRecent = toCheck.getTarget().getPackage();
            if (toCheck.getTarget() instanceof
                org.pentaho.packageManagement.VersionPackageConstraint) {
              mostRecent =
                WekaPackageManager.mostRecentVersionWithRespectToConstraint(toCheck.getTarget());
            }
            finalListToInstall.add(mostRecent);
          }
        } else {
          Package mostRecent = toCheck.getTarget().getPackage();
          if (toCheck.getTarget() instanceof
              org.pentaho.packageManagement.VersionPackageConstraint) {
            mostRecent =
              WekaPackageManager.mostRecentVersionWithRespectToConstraint(toCheck.getTarget());
          }
          finalListToInstall.add(mostRecent);
        }
      }

      if (needsUpgrade.size() > 0) {
        System.out.println("The following packages will be upgraded in order to install "
            + packageName);
        Iterator<PackageConstraint> upI = needsUpgrade.iterator();
        while (upI.hasNext()) {
          PackageConstraint tempC = upI.next();
          System.out.println("\t" + tempC);
        }

        System.out.print("\nOK to continue [y/n]? > ");
        String response = queryUser();
        if (response != null && (response.equalsIgnoreCase("n") ||
            response.equalsIgnoreCase("no"))) {
          return; // bail out here
        }

        // now take a look at the other installed packages and see if
        // any would have a problem when these ones are upgraded
        boolean conflictsAfterUpgrade = false;
        List<Package> installed = getInstalledPackages();
        List<Package> toUpgrade = new ArrayList<Package>();
        upI = needsUpgrade.iterator();
        while (upI.hasNext()) {
          toUpgrade.add(upI.next().getPackage());
        }
       
        // add the actual package the user is wanting to install if it
        // is going to be an up/downgrade rather than a first install since
        // other installed packages may depend on the currently installed version
        // and thus could be affected after the up/downgrade
        toUpgrade.add(toInstall);
       
        for (int i = 0; i < installed.size(); i++) {
          Package tempP = installed.get(i);
          String tempPName = tempP.getName();
          boolean checkIt = true;
          for (int j = 0; j < needsUpgrade.size(); j++) {
            if (tempPName.equals(needsUpgrade.get(j).getPackage().getName())) {
              checkIt = false;
              break;
            }
          }

          if (checkIt) {
            List<Dependency> problem = tempP.getIncompatibleDependencies(toUpgrade);
            if (problem.size() > 0) {
              conflictsAfterUpgrade = true;

              System.err.println("Package " + tempP.getName() + " will have a compatibility" +
              "problem with the following packages after upgrading them:");
              Iterator<Dependency> dI = problem.iterator();
              while (dI.hasNext()) {
                System.err.println("\t" + dI.next().getTarget().getPackage());
              }
            }
          }
        }

        if (conflictsAfterUpgrade) {
          System.err.println("Unable to continue with installation.");
          return; // bail out here
        }

      }
     
      if (finalListToInstall.size() > 0) {
        System.out.println("To install " + packageName + " the following packages will" +
        " be installed/upgraded:\n\n");
        Iterator<Package> i = finalListToInstall.iterator();
        while (i.hasNext()) {
          System.out.println("\t" + i.next());
        }
        System.out.print("\nOK to proceed [y/n]? > ");
        String response = queryUser();

        if (response != null && (response.equalsIgnoreCase("n") ||
            response.equalsIgnoreCase("no"))) {
          return; // bail out here
        }
      }
     
      // OK, now we can download and install everything
     
      // First install the final list of dependencies
      installPackages(finalListToInstall, System.out);
     
      // Now install the package itself
      installPackageFromRepository(packageName, version, System.out);
     
    } else {
      // just install this package without checking/downloading dependencies etc.
      installPackageFromRepository(packageName, version, System.out);
    }  
  }
 
  private static void listPackages(String arg) throws Exception {
    List<Package> packageList = null;
    useCacheOrOnlineRepository();   
   
    if (arg.equalsIgnoreCase("all")) {
      packageList = PACKAGE_MANAGER.getAllPackages();
    } else if (arg.equals("installed")) {
      packageList = PACKAGE_MANAGER.getInstalledPackages();
    } else if (arg.equals("available")) {
      packageList = PACKAGE_MANAGER.getAvailablePackages();
    } else {
      System.err.println("[WekaPackageManager] Unknown argument " + arg);
      printUsage();
      //System.exit(1);
      return;
    }
   
    StringBuffer result = new StringBuffer();
    result.append("Installed\tRepository\tPackage\n");
    result.append("=========\t==========\t=======\n");
   
    Iterator<Package> i = packageList.iterator();
    while (i.hasNext()) {
      Package p = i.next();
      String installedV = "-----    ";
      String repositoryV = "-----     ";
      if (p.isInstalled()) {
        Package installedP = getInstalledPackageInfo(p.getName());
        installedV = installedP.getPackageMetaDataElement("Version").toString() + "    ";
        try {
          Package repP = getRepositoryPackageInfo(p.getName());
          repositoryV = repP.getPackageMetaDataElement("Version").toString() + "     ";
        } catch (Exception ex) {
          // not at the repository
        }
      } else {
        repositoryV = p.getPackageMetaDataElement("Version").toString() + "     ";
      }
      String title = p.getPackageMetaDataElement("Title").toString();
      result.append(installedV + "\t" + repositoryV + "\t"
          + p.getName() + ": " + title + "\n");
    }
   
    System.out.println(result.toString());
  }
 
  private static void printUsage() {
    System.out.println("Usage: weka.core.WekaPackageManager [option]");
    System.out.println("Options:\n"
        + "\t-list-packages <all | installed | available>\n"
        + "\t-package-info <repository | installed | archive> "
        + "<packageName | packageZip>\n\t-install-package <packageName | packageZip | URL> [version]\n"
        + "\t-uninstall-package packageName\n"
        + "\t-refresh-cache");
  }
 
  public static void main(String[] args) {
    weka.core.logging.Logger.log(weka.core.logging.Logger.Level.INFO, "Logging started");
    try {
     
      establishCacheIfNeeded(System.out);
      checkForNewPackages(System.out);
     
      if (args.length == 0 || args[0].equalsIgnoreCase("-h") ||
          args[0].equalsIgnoreCase("-help")) {
        printUsage();
        //System.exit(1);
        return;
      }
     
      if (args[0].equals("-package-info")) {
        if (args.length < 3) {
          printUsage();
          return;
          //System.exit(1);
        }
        if (args[1].equals("archive")) {
          printPackageArchiveInfo(args[2]);
        } else if (args[1].equals("installed")) {
          printInstalledPackageInfo(args[2]);
        } else if (args[1].equals("repository")) {
          String version = "Latest";
          if (args.length == 4) {
            version = args[3];
          }
          try {
            printRepositoryPackageInfo(args[2], version);
          } catch (Exception ex) {
            // problem with getting info on package from repository?
            // Must not be an "official" repository package
            System.out.println("[WekaPackageManager] Nothing known about package "
                + args[2] + " at the repository!");
          }
        } else {
          System.err.println("[WekaPackageManager] Unknown argument " + args[2]);
          printUsage();
          return;
          //System.exit(1);
        }
      } else if (args[0].equals("-install-package")) {
        String targetLowerCase = args[1].toLowerCase();
        if (targetLowerCase.startsWith("http://") ||
            targetLowerCase.startsWith("https://")) {
          URL packageURL = new URL(args[1]);
          installPackageFromURL(packageURL, System.out);
        } else if (targetLowerCase.endsWith(".zip")) {
          installPackageFromArchive(args[1], System.out);
        } else {
          // assume a named package at the central repository
          String version = "Latest";
          if (args.length == 3) {
            version = args[2];
          }
          installPackageFromRepository(args[1], version, false);         
        }
      } else if (args[0].equals("-uninstall-package")) {
        if (args.length < 2) {
          printUsage();
          return;
          //System.exit(1);
        }
        boolean force = false;
       
        if (args.length == 3) {
          if (args[2].equals("-force")) {
            force = true;
          }
        }
       
        removeInstalledPackage(args[1], force, System.out);
        //System.exit(0);
        return;
      } else if (args[0].equals("-list-packages")) {
        if (args.length < 2) {
          printUsage();
          //System.exit(1);
          return;
        }
        listPackages(args[1]);
       
      } else if (args[0].equals("-refresh-cache")) {
        refreshCache(System.out);
      } else {
        System.err.println("Unknown option: " + args[0]);
        printUsage();
      }
    } catch (Exception ex) {
      ex.printStackTrace();
    }
  }
}
TOP

Related Classes of weka.core.WekaPackageManager

TOP
Copyright © 2015 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.