dart/editor/tools/plugins/com.google.dart.tools.core/src/com/google/dart/tools/core/pub/PubCacheManager_OLD.java

/*
 * Copyright (c) 2013, the Dart project authors.
 * 
 * Licensed under the Eclipse Public License v1.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.eclipse.org/legal/epl-v10.html
 * 
 * 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 com.google.dart.tools.core.pub;

import com.google.dart.tools.core.DartCore;
import com.google.dart.tools.core.utilities.yaml.PubYamlUtils;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IResourceVisitor;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.jobs.Job;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * Maintains a list of the latest versions for all packages installed in the local pub cache.
 * 
 * @coverage dart.tools.core.pub
 */
public class PubCacheManager_OLD {

  protected class FillPubCacheList extends Job {

    // Map of <packageName, version no> for packages added
    Map<String, String> packages = null;

    public FillPubCacheList(String name, Map<String, String> packages) {
      super(name);
      this.packages = packages;
    }

    @Override
    public IStatus run(IProgressMonitor monitor) {

      HashMap<String, Object> object = readPackageInfo();
      if (object != null) {
        synchronized (pubUsedPackages) {
          pubCachePackages = object;
        }
        if (packages == null) {
          initializeList();
          if (!pubUsedPackages.isEmpty()) {
            PubManager.getInstance().notifyListeners(getLocalPackages());
          }
        } else {
          Map<String, Object> added = processPackages(packages);
          if (!added.isEmpty()) {
            PubManager.getInstance().notifyListeners(added);
          }
        }
      }

      return Status.OK_STATUS;
    }

  }

  /**
   * A map to store the list of the installed packages and their locations, synchronize on
   * pubUsedPackages
   */
  // {action_consolidator=
  //    {0.1.3=
  //           {location=/Users/keertip/.pub-cache/hosted/pub.dartlang.org/action_consolidator-0.1.3}},..
  // }
  protected HashMap<String, Object> pubCachePackages = new HashMap<String, Object>();

  /**
   * A map of packages & locations used in the open folders in the editor, access should be
   * synchronized against itself
   */
  protected final HashMap<String, Object> pubUsedPackages = new HashMap<String, Object>();

  private static final PubCacheManager_OLD INSTANCE = new PubCacheManager_OLD();

  public static final PubCacheManager_OLD getInstance() {
    return INSTANCE;
  }

  // keeps track of packages last updated
  private Map<String, String> currentPackages;

  /**
   * Return information about all the cached packages
   */
  public HashMap<String, Object> getAllCachePackages() {
    synchronized (pubUsedPackages) {
      HashMap<String, Object> copy = new HashMap<String, Object>(pubCachePackages);
      return copy;
    }
  }

  /**
   * Look in the pub cache list and return the location of package-version or {@code null} if not
   * found
   * 
   * @param packageName
   * @param version
   */
  @SuppressWarnings("unchecked")
  public String getCacheLocation(String packageName, String version) {
    HashMap<String, Object> map;
    synchronized (pubUsedPackages) {
      map = (HashMap<String, Object>) pubCachePackages.get(packageName);
    }
    if (map != null && map.keySet().contains(version)) {
      return ((Map<String, String>) map.get(version)).get(PubspecConstants.LOCATION);
    }
    return null;
  }

  /**
   * Return information about all the packages currently being used in all open folders
   */
  public HashMap<String, Object> getLocalPackages() {
    synchronized (pubUsedPackages) {
      HashMap<String, Object> copy = new HashMap<String, Object>(pubUsedPackages);
      return copy;
    }
  }

  /**
   * Run pub cache list and get the latest information about all cached packages.
   */
  public HashMap<String, Object> updateAndGetAllCachePackages() {
    HashMap<String, Object> map = readPackageInfo();
    if (map != null) {
      synchronized (pubUsedPackages) {
        pubCachePackages = map;
      }
    }
    return getAllCachePackages();
  }

  public void updatePackagesList(int delay) {
    updatePackagesList(delay, null);
  }

  public void updatePackagesList(int delay, Map<String, String> packages) {
    if (currentPackages == null || !currentPackages.equals(packages)) {
      currentPackages = packages;
      new FillPubCacheList("update installed packages", packages).schedule(delay);
    }
  }

  protected IProject[] getProjects() {
    try {
      return ResourcesPlugin.getWorkspace().getRoot().getProjects();
    } catch (IllegalStateException e) {
      // The workspace is shutting down so return an empty list
      return new IProject[] {};
    }
  }

  protected String getPubCacheList() {
    RunPubCacheListJob job = new RunPubCacheListJob();
    return job.run(new NullProgressMonitor()).getMessage();
  }

  protected void processLockFileContents(IResource resource) {
    // Map<packageName,versionNo>
    Map<String, String> versionMap = PubYamlUtils.getPackageVersionMap(resource);
    if (versionMap != null && !versionMap.isEmpty()) {
      synchronized (pubUsedPackages) {
        for (String packageName : versionMap.keySet()) {
          String version = versionMap.get(packageName);
          Map<String, String> versionInfo = getVersionInfo(packageName, version);
          if (versionInfo != null) {
            versionInfo.put(PubspecConstants.VERSION, version);
            pubUsedPackages.put(packageName, versionInfo);
          }
        }
      }
    }
  }

  protected Map<String, Object> processPackages(Map<String, String> packages) {
    // Map<packageName, {{"version",versionNo}{"location",locationPath}}>
    Map<String, Object> added = new HashMap<String, Object>();
    synchronized (pubUsedPackages) {
      Set<String> usedKeySet = pubUsedPackages.keySet();
      for (String packageName : packages.keySet()) {
        String version = packages.get(packageName);
        if (!usedKeySet.contains(packageName)) {
          changeUsedPackage(added, packageName, version);
        }
        if (usedKeySet.contains(packageName)) {
          if (!getUsedVersion(packageName).equals(version)) {
            changeUsedPackage(added, packageName, version);
          }
        }
      }
    }
    return added;
  }

  private void changeUsedPackage(Map<String, Object> added, String packageName, String version) {
    Map<String, String> versionInfo = getVersionInfo(packageName, version);
    if (versionInfo != null) {
      versionInfo.put(PubspecConstants.VERSION, version);
      pubUsedPackages.put(packageName, versionInfo);
      added.put(packageName, versionInfo);
    }
  }

  @SuppressWarnings("unchecked")
  private String getUsedVersion(String packageName) {
    Map<String, String> object;
    synchronized (pubUsedPackages) {
      object = (Map<String, String>) pubUsedPackages.get(packageName);
    }
    if (object != null) {
      return object.get(PubspecConstants.VERSION);
    }
    return "";
  }

  /**
   * Checks for the location information in the pub cache information for the given package and
   * version
   * 
   * @param packageName - the name of the pub package
   * @param version - the version no of the package
   * @return Map<"location",locationPath> for the package-version
   */
  @SuppressWarnings("unchecked")
  private Map<String, String> getVersionInfo(String packageName, String version) {
    Map<String, Map<String, String>> object;
    synchronized (pubUsedPackages) {
      object = (Map<String, Map<String, String>>) pubCachePackages.get(packageName);
    }
    if (object != null) {
      Map<String, String> versionInfo = object.get(version);
      return versionInfo;
    }
    return null;
  }

  private void initializeList() {
    IProject[] projects = getProjects();
    for (IProject project : projects) {
      try {
        project.accept(new IResourceVisitor() {

          @Override
          public boolean visit(IResource resource) throws CoreException {

            if (resource.getType() != IResource.FILE) {
              return true;
            }
            if (resource.getName().equals(DartCore.PUBSPEC_LOCK_FILE_NAME)) {
              processLockFileContents(resource);
            }
            return false;
          }
        });
      } catch (CoreException e) {
        // do nothing
      }
    }

  }

  @SuppressWarnings("unchecked")
  private HashMap<String, Object> readPackageInfo() {
    String message = getPubCacheList();
    // no errors
    if (message.startsWith("{\"packages")) {
      Map<String, Object> object = null;
      try {
        object = PubYamlUtils.parsePubspecYamlToMap(message);
      } catch (Exception e) {
        DartCore.logError("Error while parsing pub cache list", e);
      }
      return (HashMap<String, Object>) object.get(PubspecConstants.PACKAGES);
    } else {
      DartCore.logError(message);
    }
    return null;
  }
}