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