root / branches / v2_0_0_prep / extensions / org.gvsig.installer / org.gvsig.installer.lib / org.gvsig.installer.lib.impl / src / main / java / org / gvsig / installer / lib / impl / DefaultDependenciesCalculator.java @ 35982
History | View | Annotate | Download (7.26 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 | import java.util.Iterator; |
||
8 | import java.util.List; |
||
9 | |||
10 | import org.gvsig.installer.lib.api.Dependencies; |
||
11 | import org.gvsig.installer.lib.api.DependenciesCalculator; |
||
12 | import org.gvsig.installer.lib.api.Dependency; |
||
13 | import org.gvsig.installer.lib.api.PackageInfo; |
||
14 | import org.gvsig.installer.lib.api.Version; |
||
15 | import org.gvsig.installer.lib.api.execution.InstallPackageService; |
||
16 | |||
17 | public class DefaultDependenciesCalculator implements DependenciesCalculator { |
||
18 | |||
19 | private InstallPackageService installService = null; |
||
20 | private List<PackageInfo> packagesInstalleds = null; |
||
21 | private List<PackageInfo> packagesToInstall = null; |
||
22 | 35982 | nfrancisco | private List<PackageInfo> requieredPackages = null; |
23 | private List<PackageInfo> conflictsPackages = null; |
||
24 | 35979 | jjdelcerro | |
25 | public DefaultDependenciesCalculator(InstallPackageService installService) {
|
||
26 | super();
|
||
27 | this.installService = installService;
|
||
28 | this.packagesInstalleds = new ArrayList<PackageInfo>(); |
||
29 | this.packagesToInstall = new ArrayList<PackageInfo>(); |
||
30 | } |
||
31 | |||
32 | private boolean addDependency(Dependencies dependencies, Dependency dependency) { |
||
33 | try {
|
||
34 | if( dependencies.contains(dependency) ) {
|
||
35 | return false; |
||
36 | } |
||
37 | Dependency dep = (Dependency) dependency.clone(); |
||
38 | dependencies.add(dep); |
||
39 | } catch (CloneNotSupportedException e) { |
||
40 | throw new RuntimeException(e); |
||
41 | } |
||
42 | return true; |
||
43 | } |
||
44 | |||
45 | private void addDependency(Dependencies dependencies, PackageInfo packageInfo) { |
||
46 | Dependencies pkgdependencies = packageInfo.getDependencies(); |
||
47 | if( pkgdependencies != null ) { |
||
48 | Iterator<Dependency> it = pkgdependencies.iterator();
|
||
49 | while( it.hasNext() ) {
|
||
50 | this.addDependency(dependencies, it.next());
|
||
51 | } |
||
52 | } |
||
53 | } |
||
54 | |||
55 | public void addPackageToInstall(PackageInfo packageInfo) { |
||
56 | this.packagesToInstall.add(packageInfo);
|
||
57 | } |
||
58 | |||
59 | public void addPackageToInstall(Collection<PackageInfo> packages) { |
||
60 | Iterator<PackageInfo> it = packages.iterator();
|
||
61 | while(it.hasNext()) {
|
||
62 | this.addPackageToInstall(it.next());
|
||
63 | } |
||
64 | } |
||
65 | |||
66 | public void addInstalledPackage(PackageInfo packageInfo) { |
||
67 | this.packagesInstalleds.add(packageInfo);
|
||
68 | } |
||
69 | |||
70 | public void addInstalledPackage(PackageInfo[] packages) { |
||
71 | for(int i=0; i<packages.length; i++) { |
||
72 | this.addInstalledPackage(packages[i]);
|
||
73 | } |
||
74 | } |
||
75 | |||
76 | public void calculate() { |
||
77 | |||
78 | // Inicializa el conjunto de paquetes ya instalados mas los que
|
||
79 | // se han solicitado instalar.
|
||
80 | List<PackageInfo> packages = new ArrayList<PackageInfo>(); |
||
81 | packages.addAll(this.packagesInstalleds);
|
||
82 | packages.addAll(this.packagesToInstall);
|
||
83 | |||
84 | List<PackageInfo> requieredPackages;
|
||
85 | |||
86 | for( int retries=0; retries<100; retries++) { |
||
87 | |||
88 | requieredPackages = new ArrayList<PackageInfo>(); |
||
89 | |||
90 | 35982 | nfrancisco | System.out.println("Pass "+ retries); |
91 | System.out.println("All packages (installed+to-install):"); |
||
92 | System.out.println(dumpPackages(packages));
|
||
93 | 35979 | jjdelcerro | |
94 | |||
95 | Dependencies dependencies = new DefaultDependencies();
|
||
96 | Iterator<PackageInfo> it = packages.iterator();
|
||
97 | while( it.hasNext() ) {
|
||
98 | this.addDependency(dependencies, it.next());
|
||
99 | } |
||
100 | 35982 | nfrancisco | System.out.println("Dependencies:"); |
101 | System.out.println(dumpDependencies(dependencies));
|
||
102 | 35979 | jjdelcerro | |
103 | for( int i=0; i<this.installService.getPackageCount(); i++ ) { |
||
104 | PackageInfo pkg = this.installService.getPackageInfo(i);
|
||
105 | // System.out.print("Check ");
|
||
106 | // System.out.println(dumpPackage(pkg));
|
||
107 | |||
108 | if( dependencies.match(Dependency.REQUIRED, pkg.getCode(), pkg.getVersion())) {
|
||
109 | PackageInfo pkg1 = getByCodeAndVersion(packages, pkg.getCode(),pkg.getVersion()); |
||
110 | if( pkg1 == null ) { |
||
111 | 35982 | nfrancisco | System.out.println(" Add required"); |
112 | 35979 | jjdelcerro | requieredPackages.add(pkg); |
113 | } |
||
114 | } |
||
115 | 35982 | nfrancisco | if( dependencies.match(Dependency.CONFLICT, pkg.getCode(), pkg.getVersion())) {
|
116 | PackageInfo pkg1 = getByCodeAndVersion(packages, pkg.getCode(),pkg.getVersion()); |
||
117 | if( pkg1 == null ) { |
||
118 | System.out.println(" Add conflicts"); |
||
119 | conflictsPackages.add(pkg); |
||
120 | } |
||
121 | } |
||
122 | // if( dependencies.match(Dependency.RECOMMENDED, pkg.getCode(), pkg.getVersion())) {
|
||
123 | // PackageInfo pkg1 = getByCodeAndVersion(packages, pkg.getCode(),pkg.getVersion());
|
||
124 | // if( pkg1 == null ) {
|
||
125 | // System.out.println(" Add conflicts");
|
||
126 | // conflictsPackages.add(pkg);
|
||
127 | // }
|
||
128 | // }
|
||
129 | 35979 | jjdelcerro | } |
130 | 35982 | nfrancisco | System.out.println("required packages:"); |
131 | System.out.println(dumpPackages(requieredPackages));
|
||
132 | 35979 | jjdelcerro | |
133 | if( requieredPackages.size() == 0 ) { |
||
134 | break;
|
||
135 | } |
||
136 | packages.addAll(requieredPackages); |
||
137 | removeDuplicateds(packages); |
||
138 | } |
||
139 | // Eliminamos de la lista de paquetes los que ya estan instalados o
|
||
140 | // los que elusuario pidio instalar.
|
||
141 | requieredPackages = new ArrayList<PackageInfo>(); |
||
142 | Iterator<PackageInfo> it = packages.iterator();
|
||
143 | while( it.hasNext() ) {
|
||
144 | PackageInfo pkg = it.next(); |
||
145 | if( this.packagesInstalleds.contains(pkg) ) { |
||
146 | continue;
|
||
147 | } |
||
148 | if( this.packagesToInstall.contains(pkg) ) { |
||
149 | continue;
|
||
150 | } |
||
151 | requieredPackages.add(pkg); |
||
152 | } |
||
153 | |||
154 | Collections.sort(requieredPackages, new Comparator<PackageInfo>() { |
||
155 | public int compare(PackageInfo o1, PackageInfo o2) { |
||
156 | return o1.getName().compareTo(o2.getName());
|
||
157 | } |
||
158 | }); |
||
159 | |||
160 | System.out.println("required packages"); |
||
161 | System.out.println(dumpPackages(requieredPackages));
|
||
162 | |||
163 | this.requieredPackages = requieredPackages;
|
||
164 | } |
||
165 | |||
166 | 35982 | nfrancisco | public List<PackageInfo> getRequiredPackages() { |
167 | return this.requieredPackages; |
||
168 | } |
||
169 | |||
170 | public List<PackageInfo> getConflictPackages() { |
||
171 | return this.conflictsPackages; |
||
172 | } |
||
173 | |||
174 | 35979 | jjdelcerro | private PackageInfo getByCodeAndVersion(Collection<PackageInfo> packages, String code, Version version) { |
175 | Iterator<PackageInfo> it1 = packages.iterator();
|
||
176 | while( it1.hasNext() ) {
|
||
177 | PackageInfo pkg1 = it1.next(); |
||
178 | if( pkg1.getCode().equalsIgnoreCase(code) ) {
|
||
179 | if( pkg1.getVersion().check(">=", version)) { |
||
180 | return pkg1;
|
||
181 | } |
||
182 | } |
||
183 | } |
||
184 | return null; |
||
185 | } |
||
186 | |||
187 | private void removeDuplicateds(List<PackageInfo> packages) { |
||
188 | |||
189 | boolean copy;
|
||
190 | List<PackageInfo> lpackages = new ArrayList<PackageInfo>(); |
||
191 | |||
192 | Iterator<PackageInfo> it1 = packages.iterator();
|
||
193 | while( it1.hasNext() ) {
|
||
194 | PackageInfo pkg1 = it1.next(); |
||
195 | copy = true;
|
||
196 | Iterator<PackageInfo> it2 = packages.iterator();
|
||
197 | while( it2.hasNext() ) {
|
||
198 | PackageInfo pkg2 = it2.next(); |
||
199 | if( pkg1 == pkg2 ) {
|
||
200 | continue;
|
||
201 | } |
||
202 | if( !pkg1.getCode().equalsIgnoreCase(pkg2.getCode())) {
|
||
203 | continue;
|
||
204 | } |
||
205 | if( pkg2.getVersion().check("<", pkg1.getVersion())) { |
||
206 | continue;
|
||
207 | } |
||
208 | copy = false;
|
||
209 | break;
|
||
210 | } |
||
211 | if( copy ) {
|
||
212 | lpackages.add(pkg1); |
||
213 | } |
||
214 | } |
||
215 | packages.clear(); |
||
216 | packages.addAll(lpackages); |
||
217 | } |
||
218 | |||
219 | |||
220 | private String dumpPackages(Collection<PackageInfo> pkgs) { |
||
221 | StringBuffer s = new StringBuffer(); |
||
222 | Iterator<PackageInfo> it = pkgs.iterator();
|
||
223 | while( it.hasNext() ) {
|
||
224 | s.append(it.next().toStringCompact()); |
||
225 | s.append("\n");
|
||
226 | } |
||
227 | |||
228 | return s.toString();
|
||
229 | } |
||
230 | |||
231 | private String dumpDependencies(Collection<Dependency> dependencies) { |
||
232 | StringBuffer s = new StringBuffer(); |
||
233 | Iterator<Dependency> it = dependencies.iterator();
|
||
234 | while( it.hasNext() ) {
|
||
235 | s.append(it.next().toString()); |
||
236 | s.append("\n");
|
||
237 | } |
||
238 | return s.toString();
|
||
239 | } |
||
240 | |||
241 | |||
242 | } |