weka.core.packageManagement.DefaultPackageManager Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of weka-dev Show documentation
The Waikato Environment for Knowledge Analysis (WEKA), a machine learning workbench. This version represents the developer version, the "bleeding edge" of development, you could say. New functionality gets added to this version.
There is a newer version: 3.9.6
Show newest version
/*
 *   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 3 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, see .
 */

/*
 *    DefaultPackageManager.java
 *    Copyright (C) 2015 University of Waikato, Hamilton, New Zealand
 *
 */
package weka.core.packageManagement;

import weka.core.Defaults;
import weka.core.Environment;
import weka.core.Settings;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.HttpURLConnection;
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.zip.ZipEntry;
import java.util.zip.ZipFile;
import java.util.zip.ZipOutputStream;

/**
 * A concrete implementation of PackageManager that uses Java properties
 * files/class to manage package meta data. Assumes that meta data for
 * individual packages is stored on the central repository (accessible via http)
 * in properties files that live in a subdirectory with the same name as the
 * package. Furthermore, each property file is assumed to be named as the
 * version number of the package in question with a ".props" extension. A
 * "Latest.props" file should exist for each package and should always hold meta
 * data on the latest version of a package.
 * 
 * @author Mark Hall (mhall{[at]}pentaho{[dot]}com)
 * @version $Revision: 52515 $
 */
public class DefaultPackageManager extends PackageManager {

  /** buffer size for copying files */
  protected static final int BUFF_SIZE = 100000;

  /** buffer used in copying files */
  protected static final byte[] m_buffer = new byte[BUFF_SIZE];

  protected static final String INSTALLED_PACKAGE_CACHE_FILE =
    "installedPackageCache.ser";

  protected static List s_installedPackageList;

  /** Timeout to use for comms */
  protected int m_timeout = DefaultPMDefaults.SOCKET_TIMEOUT;

  /** Key for the socket timeout property */
  protected static final String TIMEOUT_PROPERTY =
    "weka.packageManager.timeout";

  /**
   * Constructor
   */
  public DefaultPackageManager() {
    // set timeout based on property (if set)
    String timeout = System.getProperty(TIMEOUT_PROPERTY);
    if (timeout != null && timeout.length() > 0) {
      try {
        m_timeout = Integer.parseInt(timeout);
      } catch (NumberFormatException e) {
        // ignore quietly
      }
    }
  }

  /**
   * Get the default settings for the default package manager
   *
   * @return the default settings
   */
  @Override
  public Defaults getDefaultSettings() {

    return new DefaultPMDefaults();
  }

  /**
   * Apply settings.
   *
   * @param settings the settings to apply
   */
  @Override
  public void applySettings(Settings settings) {

    m_timeout =
      settings.getSetting(settings.getID(),
        DefaultPMDefaults.SOCKET_TIMEOUT_KEY, DefaultPMDefaults.SOCKET_TIMEOUT,
        Environment.getSystemWide());
  }

  /**
   * Default settings for the default package manager implementation
   */
  protected static final class DefaultPMDefaults extends Defaults {
    protected static final String APP_ID = "defaultpackagemanager";

    protected static final Settings.SettingKey SOCKET_TIMEOUT_KEY =
      new Settings.SettingKey(APP_ID + ".timeout",
        "Timeout (in ms) for socket " + "comms", "");
    /** Default timeout for socket connections (5 seconds) */
    protected static final int SOCKET_TIMEOUT = 5000;
    private static final long serialVersionUID = -1428588514991146709L;

    public DefaultPMDefaults() {
      super("defaultpackagemanager");
      m_defaults.put(SOCKET_TIMEOUT_KEY, SOCKET_TIMEOUT);
    }
  }

  /*
   * protected File downloadPackage2(URL packageURL, PrintStream... progress)
   * throws Exception { String packageArchiveName = packageURL.toString();
   * packageArchiveName =
   * packageArchiveName.substring(packageArchiveName.lastIndexOf('/'),
   * packageArchiveName.length()); packageArchiveName =
   * packageArchiveName.substring(0, packageArchiveName.lastIndexOf('.'));
   * 
   * // make a temp file to hold the downloaded archive File tmpDownload =
   * File.createTempFile(packageArchiveName, ".zip");
   * 
   * for (int i = 0; i < progress.length; i++) { progress[i].println(
   * "[Package Manager] Tmp file: " + tmpDownload.toString()); }
   * 
   * System.err.println("Here in downloadPackage..."); URLConnection conn =
   * null;
   * 
   * // setup the proxy (if we are using one) and open the connect if
   * (setProxyAuthentication()) { conn = packageURL.openConnection(m_httpProxy);
   * } else { conn = packageURL.openConnection(); }
   * 
   * if (conn instanceof HttpURLConnection) { System.err.println(
   * "We have a http url conn."); }
   * 
   * BufferedReader br = new BufferedReader(new
   * InputStreamReader(conn.getInputStream()));
   * 
   * String line = null;
   * 
   * while ((line = br.readLine()) != null) { System.err.println(line); }
   * 
   * br.close();
   * 
   * return null; }
   */

  protected File downloadArchive(URL packageURL, String fileExtension,
    PrintStream... progress) throws Exception {
    String packageArchiveName = packageURL.toString();

    packageArchiveName =
      packageArchiveName.substring(0,
        packageArchiveName.lastIndexOf("." + fileExtension) + 3);

    packageArchiveName =
      packageArchiveName.substring(0, packageArchiveName.lastIndexOf('.'));

    packageArchiveName =
      packageArchiveName.substring(packageArchiveName.lastIndexOf('/'),
        packageArchiveName.length());

    // make a temp file to hold the downloaded archive
    File tmpDownload =
      File.createTempFile(packageArchiveName, "." + fileExtension);

    for (PrintStream progres : progress) {
      progres.println("[DefaultPackageManager] Tmp file: "
        + tmpDownload.toString());
    }

    URLConnection conn = getConnection(packageURL);

    BufferedInputStream bi = new BufferedInputStream(conn.getInputStream());

    BufferedOutputStream bo =
      new BufferedOutputStream(new FileOutputStream(tmpDownload));

    // download the archive
    int totalBytesRead = 0;
    while (true) {
      synchronized (m_buffer) {
        int amountRead = bi.read(m_buffer);
        if (amountRead == -1) {
          for (PrintStream progres : progress) {
            progres.print("[DefaultPackageManager] downloaded "
              + (totalBytesRead / 1000) + " KB\r");
          }
          break;
        }
        bo.write(m_buffer, 0, amountRead);
        totalBytesRead += amountRead;
        for (PrintStream progres : progress) {
          progres.print("%%[DefaultPackageManager] downloaded "
            + (totalBytesRead / 1000) + " KB\r");
        }
      }
    }

    bi.close();
    bo.close();

    return tmpDownload;
  }

  /**
   * Get package information on the package at the given URL.
   * 
   * @param packageURL the URL to the package.
   * @return a Package object encapsulating the package meta data
   * @throws Exception if the package meta data can't be retrieved.
   */
  @Override
  public Package getURLPackageInfo(URL packageURL) throws Exception {
    File downloaded = downloadArchive(packageURL, "zip");

    // return the package info
    return getPackageArchiveInfo(downloaded);
  }

  /**
   * Get package information on the named package from the repository. If
   * multiple versions of the package are available, it assumes that the most
   * recent is required.
   * 
   * @param packageName the name of the package to get information about.
   * @return a Package object encapsulating the package meta data.
   * @throws Exception if the package meta data can't be retrieved.
   */
  @Override
  public Package getRepositoryPackageInfo(String packageName) throws Exception {

    return getRepositoryPackageInfo(packageName, "Latest");
  }

  /**
   * Get a list of available versions of the named package.
   * 
   * @param packageName the name of the package to get versions.
   * @return a list of available versions (or null if not applicable)
   * @throws Exception if something goes wrong while trying to retrieve the list
   *           of versions.
   */
  @Override
  public List