root / tags / v2_0_0_Build_2051 / extensions / org.gvsig.installer / org.gvsig.installer.lib / org.gvsig.installer.lib.impl / src / main / java / org / gvsig / installer / lib / impl / DefaultDependenciesCalculator.java @ 38753
History | View | Annotate | Download (8.89 KB)
1 | 35979 | jjdelcerro | package org.gvsig.installer.lib.impl; |
---|---|---|---|
2 | |||
3 | import java.util.ArrayList; |
||
4 | import java.util.Collection; |
||
5 | import java.util.Collections; |
||
6 | import java.util.Comparator; |
||
7 | 38244 | jldominguez | import java.util.HashMap; |
8 | import java.util.HashSet; |
||
9 | 35979 | jjdelcerro | import java.util.Iterator; |
10 | import java.util.List; |
||
11 | 38244 | jldominguez | import java.util.Map; |
12 | import java.util.Set; |
||
13 | 35979 | jjdelcerro | |
14 | 38244 | jldominguez | import org.slf4j.Logger; |
15 | import org.slf4j.LoggerFactory; |
||
16 | |||
17 | 35979 | jjdelcerro | import org.gvsig.installer.lib.api.Dependencies; |
18 | import org.gvsig.installer.lib.api.DependenciesCalculator; |
||
19 | import org.gvsig.installer.lib.api.Dependency; |
||
20 | import org.gvsig.installer.lib.api.PackageInfo; |
||
21 | import org.gvsig.installer.lib.api.Version; |
||
22 | import org.gvsig.installer.lib.api.execution.InstallPackageService; |
||
23 | |||
24 | public class DefaultDependenciesCalculator implements DependenciesCalculator { |
||
25 | |||
26 | 38244 | jldominguez | private static Logger logger = LoggerFactory.getLogger(DefaultDependenciesCalculator.class); |
27 | |||
28 | private InstallPackageService installService = null; |
||
29 | 35979 | jjdelcerro | private List<PackageInfo> packagesInstalleds = null; |
30 | private List<PackageInfo> packagesToInstall = null; |
||
31 | 37599 | nfrancisco | private List<PackageInfo> requieredPackages = null; |
32 | private List<PackageInfo> conflictsPackages = null; |
||
33 | 37409 | fdiaz | private Dependencies unresolvedDependencies = null; |
34 | 38244 | jldominguez | private Map<Dependency, Set<PackageInfo>> requiredPackagesOfDependency = null; |
35 | 37599 | nfrancisco | |
36 | 35979 | jjdelcerro | public DefaultDependenciesCalculator(InstallPackageService installService) {
|
37 | super();
|
||
38 | this.installService = installService;
|
||
39 | this.packagesInstalleds = new ArrayList<PackageInfo>(); |
||
40 | this.packagesToInstall = new ArrayList<PackageInfo>(); |
||
41 | 38244 | jldominguez | this.requiredPackagesOfDependency = new HashMap<Dependency, Set<PackageInfo>>(); |
42 | 35979 | jjdelcerro | } |
43 | 37599 | nfrancisco | |
44 | private boolean addDependency(Dependencies dependencies, |
||
45 | Dependency dependency) { |
||
46 | 35979 | jjdelcerro | try {
|
47 | 37599 | nfrancisco | if (dependencies.contains(dependency)) {
|
48 | 35979 | jjdelcerro | return false; |
49 | } |
||
50 | Dependency dep = (Dependency) dependency.clone(); |
||
51 | dependencies.add(dep); |
||
52 | } catch (CloneNotSupportedException e) { |
||
53 | throw new RuntimeException(e); |
||
54 | } |
||
55 | return true; |
||
56 | } |
||
57 | |||
58 | 37599 | nfrancisco | private void addDependency(Dependencies dependencies, |
59 | PackageInfo packageInfo) { |
||
60 | 38244 | jldominguez | |
61 | 35979 | jjdelcerro | Dependencies pkgdependencies = packageInfo.getDependencies(); |
62 | 37599 | nfrancisco | if (pkgdependencies != null) { |
63 | 35979 | jjdelcerro | Iterator<Dependency> it = pkgdependencies.iterator();
|
64 | 38244 | jldominguez | Dependency dependency = null;
|
65 | 37599 | nfrancisco | while (it.hasNext()) {
|
66 | 38244 | jldominguez | dependency = it.next(); |
67 | Set<PackageInfo> requirers = requiredPackagesOfDependency.get(dependency);
|
||
68 | if (requirers == null) { |
||
69 | requirers = new HashSet<PackageInfo>(); |
||
70 | requiredPackagesOfDependency.put(dependency, requirers); |
||
71 | } |
||
72 | |||
73 | this.addDependency(dependencies, dependency);
|
||
74 | requirers.add(packageInfo); |
||
75 | 35979 | jjdelcerro | } |
76 | } |
||
77 | } |
||
78 | |||
79 | public void addPackageToInstall(PackageInfo packageInfo) { |
||
80 | this.packagesToInstall.add(packageInfo);
|
||
81 | } |
||
82 | 37599 | nfrancisco | |
83 | 35979 | jjdelcerro | public void addPackageToInstall(Collection<PackageInfo> packages) { |
84 | Iterator<PackageInfo> it = packages.iterator();
|
||
85 | 37599 | nfrancisco | while (it.hasNext()) {
|
86 | 35979 | jjdelcerro | this.addPackageToInstall(it.next());
|
87 | } |
||
88 | } |
||
89 | |||
90 | public void addInstalledPackage(PackageInfo packageInfo) { |
||
91 | this.packagesInstalleds.add(packageInfo);
|
||
92 | } |
||
93 | 37599 | nfrancisco | |
94 | 35979 | jjdelcerro | public void addInstalledPackage(PackageInfo[] packages) { |
95 | 37599 | nfrancisco | for (int i = 0; i < packages.length; i++) { |
96 | 35979 | jjdelcerro | this.addInstalledPackage(packages[i]);
|
97 | } |
||
98 | } |
||
99 | 37599 | nfrancisco | |
100 | 35979 | jjdelcerro | public void calculate() { |
101 | |||
102 | 37599 | nfrancisco | // Inicializa el conjunto de paquetes ya instalados mas los que
|
103 | 35979 | jjdelcerro | // se han solicitado instalar.
|
104 | List<PackageInfo> packages = new ArrayList<PackageInfo>(); |
||
105 | packages.addAll(this.packagesInstalleds);
|
||
106 | packages.addAll(this.packagesToInstall);
|
||
107 | |||
108 | List<PackageInfo> requieredPackages;
|
||
109 | 37599 | nfrancisco | |
110 | for (int retries = 0; retries < 100; retries++) { |
||
111 | |||
112 | 35979 | jjdelcerro | requieredPackages = new ArrayList<PackageInfo>(); |
113 | |||
114 | 37599 | nfrancisco | System.out.println("Pass " + retries); |
115 | 35982 | nfrancisco | System.out.println("All packages (installed+to-install):"); |
116 | System.out.println(dumpPackages(packages));
|
||
117 | 37599 | nfrancisco | |
118 | 35979 | jjdelcerro | Dependencies dependencies = new DefaultDependencies();
|
119 | Iterator<PackageInfo> it = packages.iterator();
|
||
120 | 37599 | nfrancisco | while (it.hasNext()) {
|
121 | 35979 | jjdelcerro | this.addDependency(dependencies, it.next());
|
122 | } |
||
123 | 35982 | nfrancisco | System.out.println("Dependencies:"); |
124 | System.out.println(dumpDependencies(dependencies));
|
||
125 | 37599 | nfrancisco | |
126 | unresolvedDependencies = new DefaultDependencies();
|
||
127 | 37409 | fdiaz | unresolvedDependencies.addAll(dependencies); |
128 | 37599 | nfrancisco | |
129 | for (int i = 0; i < this.installService.getPackageCount(); i++) { |
||
130 | 35979 | jjdelcerro | PackageInfo pkg = this.installService.getPackageInfo(i);
|
131 | 37409 | fdiaz | System.out.print("Check "); |
132 | System.out.println(pkg.toStringCompact());
|
||
133 | 37599 | nfrancisco | |
134 | Dependency foundDependency = dependencies.find( |
||
135 | Dependency.REQUIRED, pkg.getCode(), pkg.getVersion()); |
||
136 | if (foundDependency != null) { |
||
137 | PackageInfo pkg1 = getByCodeAndVersion(packages, pkg |
||
138 | .getCode(), pkg.getVersion()); |
||
139 | if (pkg1 == null) { |
||
140 | 38244 | jldominguez | System.out.println(" Add required"); |
141 | 35979 | jjdelcerro | requieredPackages.add(pkg); |
142 | 37599 | nfrancisco | } |
143 | 37409 | fdiaz | unresolvedDependencies.remove(foundDependency); |
144 | 35979 | jjdelcerro | } |
145 | 37599 | nfrancisco | if (dependencies.match(Dependency.CONFLICT, pkg.getCode(), pkg
|
146 | .getVersion())) { |
||
147 | PackageInfo pkg1 = getByCodeAndVersion(packages, pkg |
||
148 | .getCode(), pkg.getVersion()); |
||
149 | if (pkg1 == null) { |
||
150 | 38244 | jldominguez | System.out.println(" Add conflicts"); |
151 | 37599 | nfrancisco | conflictsPackages.add(pkg); |
152 | } |
||
153 | } |
||
154 | // if( dependencies.match(Dependency.RECOMMENDED, pkg.getCode(),
|
||
155 | // pkg.getVersion())) {
|
||
156 | // PackageInfo pkg1 = getByCodeAndVersion(packages,
|
||
157 | // pkg.getCode(),pkg.getVersion());
|
||
158 | // if( pkg1 == null ) {
|
||
159 | // System.out.println(" Add conflicts");
|
||
160 | // conflictsPackages.add(pkg);
|
||
161 | // }
|
||
162 | // }
|
||
163 | 35979 | jjdelcerro | } |
164 | 35982 | nfrancisco | System.out.println("required packages:"); |
165 | System.out.println(dumpPackages(requieredPackages));
|
||
166 | 37599 | nfrancisco | |
167 | if (requieredPackages.size() == 0) { |
||
168 | 35979 | jjdelcerro | break;
|
169 | } |
||
170 | packages.addAll(requieredPackages); |
||
171 | removeDuplicateds(packages); |
||
172 | } |
||
173 | // Eliminamos de la lista de paquetes los que ya estan instalados o
|
||
174 | // los que elusuario pidio instalar.
|
||
175 | requieredPackages = new ArrayList<PackageInfo>(); |
||
176 | Iterator<PackageInfo> it = packages.iterator();
|
||
177 | 37599 | nfrancisco | while (it.hasNext()) {
|
178 | 35979 | jjdelcerro | PackageInfo pkg = it.next(); |
179 | 37599 | nfrancisco | if (this.packagesInstalleds.contains(pkg)) { |
180 | 35979 | jjdelcerro | continue;
|
181 | } |
||
182 | 37599 | nfrancisco | if (this.packagesToInstall.contains(pkg)) { |
183 | 35979 | jjdelcerro | continue;
|
184 | } |
||
185 | requieredPackages.add(pkg); |
||
186 | } |
||
187 | 37599 | nfrancisco | |
188 | 35979 | jjdelcerro | Collections.sort(requieredPackages, new Comparator<PackageInfo>() { |
189 | public int compare(PackageInfo o1, PackageInfo o2) { |
||
190 | return o1.getName().compareTo(o2.getName());
|
||
191 | } |
||
192 | }); |
||
193 | 37599 | nfrancisco | |
194 | 35979 | jjdelcerro | System.out.println("required packages"); |
195 | System.out.println(dumpPackages(requieredPackages));
|
||
196 | |||
197 | this.requieredPackages = requieredPackages;
|
||
198 | 38244 | jldominguez | dumpUnresolvedDependencies(); |
199 | |||
200 | 35979 | jjdelcerro | } |
201 | 38244 | jldominguez | |
202 | private void dumpUnresolvedDependencies() { |
||
203 | |||
204 | Iterator<Dependency> iter = unresolvedDependencies.iterator();
|
||
205 | while (iter.hasNext()) {
|
||
206 | Dependency dep = iter.next(); |
||
207 | Set<PackageInfo> required = requiredPackagesOfDependency.get(dep);
|
||
208 | if (required != null) { |
||
209 | StringBuffer str_buffer = new StringBuffer(); |
||
210 | str_buffer.append("Unresolved dependency: " + dep.toString() + " required by:\n"); |
||
211 | Iterator<PackageInfo> iter2 = required.iterator();
|
||
212 | while (iter2.hasNext()) {
|
||
213 | str_buffer.append(" - " + iter2.next().toStringCompact() + "\n"); |
||
214 | } |
||
215 | logger.info(str_buffer.toString()); |
||
216 | } |
||
217 | } |
||
218 | |||
219 | } |
||
220 | 35979 | jjdelcerro | |
221 | 37599 | nfrancisco | public List<PackageInfo> getRequiredPackages() { |
222 | return this.requieredPackages; |
||
223 | } |
||
224 | 37409 | fdiaz | |
225 | 37599 | nfrancisco | public List<PackageInfo> getConflictPackages() { |
226 | return this.conflictsPackages; |
||
227 | } |
||
228 | 37409 | fdiaz | |
229 | 37599 | nfrancisco | public Dependencies getUnresolvedDependencies() {
|
230 | return this.unresolvedDependencies; |
||
231 | } |
||
232 | |||
233 | private PackageInfo getByCodeAndVersion(Collection<PackageInfo> packages, |
||
234 | String code, Version version) {
|
||
235 | 35979 | jjdelcerro | Iterator<PackageInfo> it1 = packages.iterator();
|
236 | 37599 | nfrancisco | while (it1.hasNext()) {
|
237 | 35979 | jjdelcerro | PackageInfo pkg1 = it1.next(); |
238 | 37599 | nfrancisco | if (pkg1.getCode().equalsIgnoreCase(code)) {
|
239 | if (pkg1.getVersion().check(">=", version)) { |
||
240 | 35979 | jjdelcerro | return pkg1;
|
241 | } |
||
242 | } |
||
243 | } |
||
244 | return null; |
||
245 | } |
||
246 | 37599 | nfrancisco | |
247 | 35979 | jjdelcerro | private void removeDuplicateds(List<PackageInfo> packages) { |
248 | |||
249 | boolean copy;
|
||
250 | List<PackageInfo> lpackages = new ArrayList<PackageInfo>(); |
||
251 | 37599 | nfrancisco | |
252 | 35979 | jjdelcerro | Iterator<PackageInfo> it1 = packages.iterator();
|
253 | 37599 | nfrancisco | while (it1.hasNext()) {
|
254 | 35979 | jjdelcerro | PackageInfo pkg1 = it1.next(); |
255 | copy = true;
|
||
256 | Iterator<PackageInfo> it2 = packages.iterator();
|
||
257 | 37599 | nfrancisco | while (it2.hasNext()) {
|
258 | 35979 | jjdelcerro | PackageInfo pkg2 = it2.next(); |
259 | 37599 | nfrancisco | if (pkg1 == pkg2) {
|
260 | 35979 | jjdelcerro | continue;
|
261 | } |
||
262 | 37599 | nfrancisco | if (!pkg1.getCode().equalsIgnoreCase(pkg2.getCode())) {
|
263 | 35979 | jjdelcerro | continue;
|
264 | } |
||
265 | 37599 | nfrancisco | if (pkg2.getVersion().check("<", pkg1.getVersion())) { |
266 | 35979 | jjdelcerro | continue;
|
267 | } |
||
268 | copy = false;
|
||
269 | break;
|
||
270 | } |
||
271 | 37599 | nfrancisco | if (copy) {
|
272 | 35979 | jjdelcerro | lpackages.add(pkg1); |
273 | 37599 | nfrancisco | } |
274 | 35979 | jjdelcerro | } |
275 | packages.clear(); |
||
276 | packages.addAll(lpackages); |
||
277 | } |
||
278 | |||
279 | private String dumpPackages(Collection<PackageInfo> pkgs) { |
||
280 | StringBuffer s = new StringBuffer(); |
||
281 | Iterator<PackageInfo> it = pkgs.iterator();
|
||
282 | 37599 | nfrancisco | while (it.hasNext()) {
|
283 | 35979 | jjdelcerro | s.append(it.next().toStringCompact()); |
284 | s.append("\n");
|
||
285 | } |
||
286 | 37599 | nfrancisco | |
287 | 35979 | jjdelcerro | return s.toString();
|
288 | } |
||
289 | |||
290 | private String dumpDependencies(Collection<Dependency> dependencies) { |
||
291 | StringBuffer s = new StringBuffer(); |
||
292 | Iterator<Dependency> it = dependencies.iterator();
|
||
293 | 37599 | nfrancisco | while (it.hasNext()) {
|
294 | 35979 | jjdelcerro | s.append(it.next().toString()); |
295 | s.append("\n");
|
||
296 | } |
||
297 | return s.toString();
|
||
298 | } |
||
299 | |||
300 | } |