1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
/*******************************************************************************
* Copyright (c) 2007 IBM Corporation and others. All rights reserved. This
* program and the accompanying materials are made available under the terms of
* the Eclipse Public License v1.0 which accompanies this distribution, and is
* available at http://www.eclipse.org/legal/epl-v10.html
*
* Contributors: IBM Corporation - initial API and implementation
******************************************************************************/
package org.eclipse.equinox.internal.p2.director;
import java.util.*;
import org.eclipse.core.runtime.*;
import org.eclipse.equinox.internal.p2.core.helpers.LogHelper;
import org.eclipse.equinox.internal.provisional.p2.metadata.IInstallableUnit;
import org.eclipse.equinox.internal.provisional.p2.metadata.RequiredCapability;
import org.eclipse.equinox.internal.provisional.p2.metadata.query.CapabilityQuery;
import org.eclipse.equinox.internal.provisional.p2.query.Collector;
import org.eclipse.equinox.internal.provisional.p2.query.IQueryable;
import org.osgi.framework.InvalidSyntaxException;
public class Slicer {
private static boolean DEBUG = false;
private IQueryable possibilites;
private LinkedList toProcess;
private Set considered; //IUs to add to the slice
private TwoTierMap slice; //The IUs that have been considered to be part of the problem
private Dictionary selectionContext;
private MultiStatus result;
public Slicer(IQueryable input, Dictionary context) {
possibilites = input;
slice = new TwoTierMap();
selectionContext = context;
result = new MultiStatus(DirectorActivator.PI_DIRECTOR, IStatus.OK, "Problems resolving provisioning plan.", null);
}
public Slicer(IInstallableUnit[] installRoots, IInstallableUnit[] gatherAvailableInstallableUnits, Dictionary selectionContext) {
this(new QueryableArray(gatherAvailableInstallableUnits), selectionContext);
}
public IQueryable slice(IInstallableUnit[] ius, IProgressMonitor monitor) {
try {
long start = 0;
if (DEBUG) {
start = System.currentTimeMillis();
System.out.println("Start slicing: " + start); //$NON-NLS-1$
}
validateInput(ius);
considered = new HashSet(Arrays.asList(ius));
toProcess = new LinkedList(considered);
while (!toProcess.isEmpty())
processIU((IInstallableUnit) toProcess.removeFirst());
if (DEBUG) {
long stop = System.currentTimeMillis();
System.out.println("Slicing complete: " + (stop - start)); //$NON-NLS-1$
}
} catch (IllegalStateException e) {
result.add(new Status(IStatus.ERROR, DirectorActivator.PI_DIRECTOR, e.getMessage(), e));
}
if (!result.isOK())
LogHelper.log(result);
if (result.getSeverity() == IStatus.ERROR)
return null;
return new QueryableArray((IInstallableUnit[]) considered.toArray(new IInstallableUnit[considered.size()]));
}
public MultiStatus getStatus() {
return result;
}
//This is a shortcut to simplify the error reporting when the filter of the ius we are being asked to install does not pass
private void validateInput(IInstallableUnit[] ius) {
//TODO Need to see what is done in validateInput of PBProjector
for (int i = 0; i < ius.length; i++) {
if (!isApplicable(ius[i]))
throw new IllegalStateException("The IU " + ius[i] + " can't be installed in this environment because its filter does not match."); //$NON-NLS-1$//$NON-NLS-2$
}
}
// Check whether the requirement is applicable
private boolean isApplicable(RequiredCapability req) {
String filter = req.getFilter();
if (filter == null)
return true;
try {
return DirectorActivator.context.createFilter(filter).match(selectionContext);
} catch (InvalidSyntaxException e) {
return false;
}
}
private boolean isApplicable(IInstallableUnit iu) {
String enablementFilter = iu.getFilter();
if (enablementFilter == null)
return true;
try {
return DirectorActivator.context.createFilter(enablementFilter).match(selectionContext);
} catch (InvalidSyntaxException e) {
return false;
}
}
private void processIU(IInstallableUnit iu) {
slice.put(iu.getId(), iu.getVersion(), iu);
if (!isApplicable(iu)) {
return;
}
RequiredCapability[] reqs = iu.getRequiredCapabilities();
if (reqs.length == 0) {
return;
}
for (int i = 0; i < reqs.length; i++) {
if (!isApplicable(reqs[i]))
continue;
if (!reqs[i].isGreedy()) {
continue;
}
expandRequirement(iu, reqs[i]);
}
}
private void expandRequirement(IInstallableUnit iu, RequiredCapability req) {
Collector matches = possibilites.query(new CapabilityQuery(req), new Collector(), null);
int validMatches = 0;
for (Iterator iterator = matches.iterator(); iterator.hasNext();) {
IInstallableUnit match = (IInstallableUnit) iterator.next();
if (!isApplicable(match))
continue;
validMatches++;
if (!slice.containsKey(match.getId(), match.getVersion()))
consider(match);
}
if (validMatches == 0) {
if (req.isOptional()) {
if (DEBUG)
System.out.println("No IU found to satisfy optional dependency of " + iu + " on req " + req); //$NON-NLS-1$//$NON-NLS-2$
} else {
result.add(new Status(IStatus.WARNING, DirectorActivator.PI_DIRECTOR, "No IU found to satisfy dependency of " + iu + " on req " + req)); //$NON-NLS-1$//$NON-NLS-2$
}
}
}
private void consider(IInstallableUnit match) {
if (considered.add(match))
toProcess.addLast(match);
}
}
|
