/*
* Copyright (C) 2012 The Android Open Source Project
*
* 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 com.motorola.studio.android.installer.utilities;
import java.net.URI;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.SubMonitor;
import org.eclipse.equinox.p2.metadata.IInstallableUnit;
import org.eclipse.equinox.p2.operations.InstallOperation;
import org.eclipse.equinox.p2.operations.Update;
import org.eclipse.equinox.p2.operations.UpdateOperation;
import org.eclipse.equinox.p2.query.IQuery;
import org.eclipse.equinox.p2.query.QueryUtil;
import org.eclipse.equinox.p2.repository.metadata.IMetadataRepository;
import com.motorola.studio.android.common.log.StudioLogger;
import com.motorola.studio.android.installer.InstallerException;
import com.motorola.studio.android.installer.InstallerPlugin;
import com.motorola.studio.android.installer.i18n.InstallerNLS;
import com.motorola.studio.android.installer.utilities.IInstallManager.BACKEND;
import com.motorola.studio.android.installer.utilities.IInstallManager.CATEGORY;
/**
* Implements the methods for using the INstall framework with P2
*/
class P2Installer
{
private final String LANGUAGE_PACK_QUERY =
"this.id ~= /com.motorola.studio.android.feature.nl*/";
private final String NKD_QUERY = "org.eclipse.sequoyah.android.cdt.feature.feature.group";
private final String SUBVERSION_QUERY = "org.eclipse.team.svn.feature.group";
private final String EGIT_QUERY = "org.eclipse.egit.feature.group";
private final String MYLYN_QUERY1 = "org.eclipse.mylyn.context_feature.feature.group";
private final String MYLYN_QUERY2 = "org.eclipse.mylyn_feature.feature.group";
private final String CVS_QUERY = "org.eclipse.cvs.feature.group";
private final HashMap<URI, IMetadataRepository> mainRepositories =
new HashMap<URI, IMetadataRepository>();
//will be used to record an instance of a InstallOperation. If it did not exist, we would have to instantiate
//the InstallOperation on validate and download methods
private InstallOperation installOp;
private UpdateOperation up;
/**
*
*/
public void resetP2Installer()
{
mainRepositories.clear();
installOp = null;
}
private boolean isAllRepositoriesLoaded(Collection<URI> links)
{
boolean isAllLoaded = false;
if (!mainRepositories.isEmpty())
{
isAllLoaded = true;
for (URI uri : links)
{
if (!mainRepositories.containsKey(uri))
{
isAllLoaded = false;
break;
}
}
}
return isAllLoaded;
}
/**
* Load the P2 repositories.
* Initially the method verifies if the repositories were already instantiated and is
* on the metadata and arfacts maps (metadataRepositoriesMap, artifactRepositoriesMap).
* If yes, they should not be instantiated again. Otherwise, the repository and its references
* will be loaded.
*
* If the global maps did not exist, every time that methods validateInstallation, listAvailableUpdates
* and downloadAndInstall were called, all the repositories would be loaded again.
*/
private IStatus loadRepositories(List<URI> links, IProgressMonitor monitor)
{
StudioLogger.debug(this, "loading repositories...");
IStatus status = Status.OK_STATUS;
StudioLogger.debug(this, "there are not loaded repositories");
SubMonitor submonitor = SubMonitor.convert(monitor);
int reposSize = 0;
if (links != null)
{
reposSize += links.size();
}
submonitor.beginTask(InstallerNLS.AbstractConfigurationPage_LoadingRepositoriesTask,
reposSize * 100);
boolean isAllRepositoriesLoaded = isAllRepositoriesLoaded(links);
if (!isAllRepositoriesLoaded)
{
P2RepositoriesFactory p2RepositoriesFactory = P2RepositoriesFactory.getInstance();
for (URI uri : links)
{
IMetadataRepository metadataRepository = null;
//loads metadata repositories from URIs
try
{
metadataRepository =
p2RepositoriesFactory.getMetadataRepository(uri, true,
submonitor.newChild(100));
mainRepositories.put(uri, metadataRepository);
}
catch (Exception e)
{
status = new Status(IStatus.WARNING, InstallerPlugin.PLUGIN_ID, e.getMessage());
StudioLogger.error(this.getClass(),
"could not instantiate repository from URI " + uri);
}
}
}
else
{
submonitor.done();
}
return status;
}
/**
* Loads InstallableItems based on category and links. They are put into the collection listToFill
*
* @param listToFill
* @param links
* @param category
* @param monitor
* @return
* @throws InstallerException
*/
public IStatus listAllAvailableInstallItems(Collection<InstallableItem> listToFill,
List<URI> uriList, CATEGORY category, IProgressMonitor monitor)
throws InstallerException
{
StudioLogger.debug(this, "listing available installable items...");
IStatus status =
new Status(IStatus.ERROR, InstallerPlugin.PLUGIN_ID, 0,
InstallerNLS.P2Installer_Could_Not_Find_Proper_Backend, null);
//this links list is created because the method loadRepositories remove some items of the list
//if the repositorie is already loaded.
List<URI> links = new ArrayList<URI>();
links.addAll(uriList);
SubMonitor submonitor = SubMonitor.convert(monitor);
submonitor.beginTask(InstallerNLS.P2Installer_Loading_Repositories, 100);
status = loadRepositories(links, submonitor.newChild(20));
Collection<IInstallableUnit> units = new HashSet<IInstallableUnit>();
IQuery<IInstallableUnit> query = null;
//category is used to create the correct query
switch (category)
{
case LANG_PACKS:
{
//Filter IUs in order to receive only lang packs
query = QueryUtil.createMatchQuery(LANGUAGE_PACK_QUERY); //$NON-NLS-1$
break;
}
case NDK:
{
//Filter IUs in order to receive only NDK related
query = QueryUtil.createIUQuery(NKD_QUERY); //$NON-NLS-1$
break;
}
case UPDATE_STUDIO:
{
//No special query needed
break;
}
case OTHER_COMPONENTS:
{
Collection<IQuery<IInstallableUnit>> queries =
new ArrayList<IQuery<IInstallableUnit>>();
queries.add(QueryUtil.createIUQuery(SUBVERSION_QUERY));
queries.add(QueryUtil.createIUQuery(MYLYN_QUERY1));
queries.add(QueryUtil.createIUQuery(MYLYN_QUERY2));
queries.add(QueryUtil.createIUQuery(CVS_QUERY));
queries.add(QueryUtil.createIUQuery(EGIT_QUERY));
query = QueryUtil.createCompoundQuery(queries, false);
break;
}
default:
{
// No specific query to use as filter, download them all!
break;
}
}
int monitorWorkSize = 0;
try
{
monitorWorkSize = 40 / mainRepositories.values().size();
}
catch (ArithmeticException e)
{
// Do nothing
}
for (Iterator<IMetadataRepository> iterator = mainRepositories.values().iterator(); iterator
.hasNext();)
{
IMetadataRepository repository = iterator.next();
try
{
Collection<IInstallableUnit> ius =
P2Utilities.getInstallableUnits(repository, query,
submonitor.newChild(monitorWorkSize));
units.addAll(ius);
status = Status.OK_STATUS;
}
catch (InstallerException e)
{
StudioLogger.error(this.getClass(), "could not retrieve installable units");
status =
new Status(IStatus.ERROR, InstallerPlugin.PLUGIN_ID, 0,
"Error retrieving available installable units", null);
}
}
monitorWorkSize = 0;
try
{
monitorWorkSize = 40 / units.size();
}
catch (ArithmeticException e)
{
// Do nothing
}
for (Iterator<IInstallableUnit> iterator = units.iterator(); iterator.hasNext();)
{
IInstallableUnit iInstallableUnit = iterator.next();
if (P2Utilities.isGroup(iInstallableUnit))
{
// I'm only returning groups since only groups
// are listed for the user to select what to install
InstallableItem item = iu2InstallableItem(iInstallableUnit, monitor);
listToFill.add(item);
}
}
if (status.getMessage().equals("org.eclipse.core.runtime.OperationCanceledException"))
{
StudioLogger.debug(this, "operation was canceled");
status =
new Status(Status.CANCEL, status.getPlugin(), status.getCode(),
status.getMessage(), status.getException());
}
submonitor.done();
return status;
}
//Translates a P2 installable unit to a InstallableItem object
private InstallableItem iu2InstallableItem(IInstallableUnit unit, IProgressMonitor monitor)
throws InstallerException
{
InstallableItem item = new P2InstallableItem();
item.setData(unit);
item.setBundleID(unit.getId());
item.setInstalled(P2Utilities.isInstalled(unit, monitor));
item.setLicense(P2Utilities.getLicenseText(unit));
item.setDisplayName(P2Utilities.getIUExternalizedValue(unit, IInstallableUnit.PROP_NAME));
item.setDescription(P2Utilities.getIUExternalizedValue(unit,
IInstallableUnit.PROP_DESCRIPTION));
item.setProvider(P2Utilities.getIUExternalizedValue(unit, IInstallableUnit.PROP_PROVIDER));
item.setRequirementsIds(P2Utilities.getRequirements(unit));
return item;
}
/**
* Method used to install the installable items. The repositories and installOp should be already loaded,
* otherwise they will be.
*
* @param links
* @param itemsToDownloadAndInstall
* @param monitor
* @return
*/
public IStatus downloadAndInstall(List<URI> links,
Collection<InstallableItem> itemsToDownloadAndInstall, IProgressMonitor monitor)
{
StudioLogger.debug(this, "downloadAndInstall: installing selected installable items");
IStatus status =
new Status(IStatus.ERROR, InstallerPlugin.PLUGIN_ID, 0,
InstallerNLS.P2Installer_Could_Not_Install_Selected_Items, null);
if ((itemsToDownloadAndInstall != null) && (!itemsToDownloadAndInstall.isEmpty()))
{
final List<IInstallableUnit> installableUnits = new ArrayList<IInstallableUnit>();
for (InstallableItem item : itemsToDownloadAndInstall)
{
IInstallableUnit unit = (IInstallableUnit) item.getData();
installableUnits.add(unit);
}
try
{
if (installOp == null)
{
status = loadRepositories(links, monitor);
status =
P2Utilities.installIu(installableUnits, mainRepositories.values(),
monitor);
}
else
{
status = P2Utilities.installIu(installableUnits, installOp, monitor);
}
}
catch (InstallerException e)
{
StudioLogger.error(this.getClass(), "could not install selected installable unit");
status = new Status(IStatus.WARNING, InstallerPlugin.PLUGIN_ID, e.getMessage());
}
//clean installOp and maps. After the installation has occurred, they can be cleaned.
installOp = null;
mainRepositories.clear();
return status;
}
return status;
}
/**
* Updates studio.
* IMPORTANT: the method listAllAvailableUpdates MUST be called first
*
* @param monitor
* @return
*/
public IStatus updateStudio(IProgressMonitor monitor)
{
StudioLogger.debug(this, "updateStudio: installing selected installable items");
IStatus status =
new Status(IStatus.ERROR, InstallerPlugin.PLUGIN_ID, 0,
InstallerNLS.P2Installer_Could_Not_Install_Selected_Items, null);
try
{
status = P2Utilities.updateIu(up, monitor);
}
catch (Exception e)
{
StudioLogger.error(this.getClass(), "could not install selected installable unit.", e);
status = new Status(IStatus.WARNING, InstallerPlugin.PLUGIN_ID, e.getMessage());
}
return status;
}
/**
* @param itemsToDownloadAndInstall
* @param backEnd
* @param monitor
* @return
*/
public IStatus validateInstallation(List<URI> links,
Collection<InstallableItem> itemsToDownloadAndInstall, BACKEND backEnd,
IProgressMonitor monitor)
{
// installOp will be loaded as global variable because will be used on method downloadAndInstall.
// It must not be instantiated twice if it were already validated.
installOp = null;
List<URI> allURIs = new ArrayList<URI>(mainRepositories.keySet());
for (Iterator<URI> iterator = allURIs.iterator(); iterator.hasNext();)
{
URI uri = iterator.next();
if (!links.contains(uri))
{
mainRepositories.remove(uri);
}
}
Collection<IInstallableUnit> temp = new HashSet<IInstallableUnit>();
loadRepositories(links, monitor);
for (Iterator<InstallableItem> iterator = itemsToDownloadAndInstall.iterator(); iterator
.hasNext();)
{
InstallableItem iInstallableItem = iterator.next();
temp.add((IInstallableUnit) iInstallableItem.getData());
}
if ((itemsToDownloadAndInstall != null) && (itemsToDownloadAndInstall.size() > 0))
{
try
{
installOp =
P2Utilities.getInstallOperation(temp, mainRepositories.values(), monitor);
}
catch (InstallerException e)
{
StudioLogger.error(this.getClass(), "Could not retrieve install operation");
return new Status(IStatus.ERROR, InstallerPlugin.PLUGIN_ID, 0, e.getMessage(), null);
}
}
return installOp != null ? installOp.getResolutionResult() : Status.CANCEL_STATUS;
}
/**
* Lists all available updates given a link.
* After this method the method updateStudio can be invoked
*
* @param listToFill
* @param links
* @param category
* @param backEnd
* @param monitor
* @return
* @throws InstallerException
*/
public IStatus listAllAvailableUpdates(Collection<InstallableItem> listToFill, List<URI> links,
CATEGORY category, BACKEND backEnd, IProgressMonitor monitor) throws InstallerException
{
IStatus result = Status.OK_STATUS;
try
{
up = P2Utilities.getUpdateOperation(links, monitor);
if (up != null)
{
result = up.getResolutionResult();
Update[] updates = up.getSelectedUpdates();
if (listToFill != null)
{
for (int i = 0; i < updates.length; i++)
{
InstallableItem item = iu2InstallableItem(updates[i].replacement, monitor);
listToFill.add(item);
}
}
}
else
{
result = Status.CANCEL_STATUS;
}
}
catch (Exception e)
{
StudioLogger.error(this.getClass(), "Error looking for updates. ", e);
result = new Status(IStatus.ERROR, InstallerPlugin.PLUGIN_ID, 0, e.getMessage(), null);
}
return result;
}
}