source: java/installer2/src/net/oni2/aeinstaller/backend/packages/PackageManager.java@ 1202

Last change on this file since 1202 was 1202, checked in by alloc, 17 hours ago

AEI 2.31: Fixes for reading offline package cache
File size: 11.2 KB
RevLine 
[648]1package net.oni2.aeinstaller.backend.packages;
2
3import java.io.File;
4import java.io.FileFilter;
5import java.io.FileInputStream;
6import java.io.FileNotFoundException;
7import java.io.FileOutputStream;
8import java.io.IOException;
[1202]9import java.io.InputStreamReader;
10import java.io.Reader;
[648]11import java.util.Collection;
12import java.util.HashMap;
13import java.util.HashSet;
[863]14import java.util.Iterator;
[648]15import java.util.TreeSet;
16import java.util.Vector;
17
18import net.oni2.aeinstaller.backend.Paths;
[809]19import net.oni2.aeinstaller.backend.oni.management.ModInstallationList;
[804]20import net.oni2.aeinstaller.backend.oni.management.tools.ToolInstallationList;
[749]21import net.oni2.moddepot.DepotManager;
22import net.oni2.moddepot.model.NodeMod;
23import net.oni2.moddepot.model.TaxonomyTerm;
[648]24
[658]25import com.thoughtworks.xstream.XStream;
[857]26import com.thoughtworks.xstream.XStreamException;
[658]27import com.thoughtworks.xstream.io.xml.StaxDriver;
28
[648]29/**
30 * @author Christian Illy
31 */
32public class PackageManager {
33 private static PackageManager instance = new PackageManager();
34
35 private HashMap<String, Type> types = new HashMap<String, Type>();
36 private HashMap<Integer, Package> mods = new HashMap<Integer, Package>();
37 private HashMap<Integer, Package> tools = new HashMap<Integer, Package>();
[857]38 private Type localType = null;
[648]39
[860]40 private HashMap<Integer, Package> newToolsOnDepot = new HashMap<Integer, Package>();
41 private HashMap<Integer, Package> newModsOnDepot = new HashMap<Integer, Package>();
42
[648]43 /**
44 * @param f
45 * Mod selection file
46 * @return Mod selection
47 */
48 @SuppressWarnings("unchecked")
49 public Vector<Integer> loadModSelection(File f) {
50 Vector<Integer> res = new Vector<Integer>();
51 try {
52 if (f.exists()) {
53 FileInputStream fis = new FileInputStream(f);
54 XStream xs = new XStream(new StaxDriver());
55 Object obj = xs.fromXML(fis);
56 if (obj instanceof Vector<?>)
57 res = (Vector<Integer>) obj;
58 fis.close();
59 }
60 } catch (FileNotFoundException e) {
61 e.printStackTrace();
62 } catch (IOException e) {
63 e.printStackTrace();
64 }
65 return res;
66 }
67
68 /**
69 * @param f
70 * Mod selection file
71 * @param mods
72 * Selected mods
73 */
74 public void saveModSelection(File f, TreeSet<Package> mods) {
75 try {
76 Vector<Integer> installed = new Vector<Integer>();
77 for (Package m : mods) {
78 installed.add(m.getPackageNumber());
79 }
80 FileOutputStream fos = new FileOutputStream(f);
81 XStream xs = new XStream(new StaxDriver());
82 xs.toXML(installed, fos);
83 fos.close();
84 } catch (FileNotFoundException e) {
85 e.printStackTrace();
86 } catch (IOException e) {
87 e.printStackTrace();
88 }
89 }
90
91 /**
92 * First initialization of ModManager
93 */
94 public void init() {
[860]95 HashMap<Integer, Package> oldMods = mods;
96 HashMap<Integer, Package> oldTools = tools;
97
[648]98 types = new HashMap<String, Type>();
99 mods = new HashMap<Integer, Package>();
[860]100 tools = new HashMap<Integer, Package>();
[648]101
[860]102 newModsOnDepot = new HashMap<Integer, Package>();
103 newToolsOnDepot = new HashMap<Integer, Package>();
104
[857]105 localType = new Type("-Local-");
[648]106 types.put("-Local-", localType);
107
108 for (TaxonomyTerm tt : DepotManager.getInstance().getTypes()) {
[749]109 types.put(tt.getName(), new Type(tt.getName()));
[648]110 }
111
112 for (NodeMod nm : DepotManager.getInstance().getModPackageNodes()) {
[749]113 if (nm.getUploads().size() == 1) {
[648]114 Package m = new Package(nm);
[860]115 if (nm.isTool()) {
[648]116 tools.put(m.getPackageNumber(), m);
[860]117 if (!oldTools.containsKey(m.getPackageNumber()))
118 newToolsOnDepot.put(m.getPackageNumber(), m);
119 } else {
[648]120 mods.put(m.getPackageNumber(), m);
[860]121 if (!oldMods.containsKey(m.getPackageNumber()))
122 newModsOnDepot.put(m.getPackageNumber(), m);
123 }
[648]124 }
125 }
126
[857]127 updateLocalData();
[648]128 }
129
130 /**
131 * @return Singleton instance
132 */
133 public static PackageManager getInstance() {
134 return instance;
135 }
136
137 Type getTypeByName(String name) {
138 return types.get(name);
139 }
140
141 /**
142 * @return Collection of types which do have mods associated
143 */
144 public Collection<Type> getTypesWithContent() {
145 Vector<Type> res = new Vector<Type>();
146 for (Type t : types.values()) {
147 if (t.getEntries().size() > 0)
148 res.add(t);
149 }
150 return res;
151 }
152
153 /**
154 * @return Collection of mods valid on this platform and not core package
155 */
156 public Collection<Package> getModsValidAndNotCore() {
157 Vector<Package> res = new Vector<Package>();
158 for (Package m : mods.values())
159 if (m.isValidOnPlatform() && !m.isCorePackage())
160 res.add(m);
161 return res;
162 }
163
164 /**
165 * @return Mods which are always installed and valid on this platform
166 */
167 public TreeSet<Package> getCoreMods() {
168 TreeSet<Package> res = new TreeSet<Package>();
169 for (Package m : mods.values()) {
170 if (m.isValidOnPlatform() && m.isCorePackage())
171 res.add(m);
172 }
173 return res;
174 }
175
176 /**
177 * @return Mods which are already locally available
178 */
179 public TreeSet<Package> getLocalAvailableMods() {
180 TreeSet<Package> res = new TreeSet<Package>();
181 for (Package m : mods.values()) {
182 if (m.isLocalAvailable())
183 res.add(m);
184 }
185 return res;
186 }
187
188 /**
189 * @return Mods which can be updated
190 */
191 public TreeSet<Package> getUpdatableMods() {
192 TreeSet<Package> res = new TreeSet<Package>();
193 for (Package m : getLocalAvailableMods()) {
194 if (m.isNewerAvailable())
195 res.add(m);
196 }
197 return res;
198 }
199
200 /**
[807]201 * @return Currently installed mods
202 */
203 public TreeSet<Package> getInstalledMods() {
204 TreeSet<Package> res = new TreeSet<Package>();
[809]205 for (int n : ModInstallationList.getInstance().getInstalledMods()) {
[807]206 res.add(getPackageByNumber(n));
207 }
208 return res;
209 }
210
211 /**
[648]212 * @return Collection of tools valid on this platform and not core
213 */
[658]214 public Collection<Package> getTools() {
215 Vector<Package> res = new Vector<Package>();
[648]216 for (Package m : tools.values())
217 if (m.isValidOnPlatform() && !m.isCorePackage())
[658]218 res.add(m);
[648]219 return res;
220 }
221
222 /**
223 * @return Tools which are always installed and valid on this platform
224 */
225 public TreeSet<Package> getCoreTools() {
226 TreeSet<Package> res = new TreeSet<Package>();
227 for (Package m : tools.values()) {
228 if (m.isValidOnPlatform() && m.isCorePackage())
229 res.add(m);
230 }
231 return res;
232 }
233
234 /**
235 * @return Tools which are already locally available
236 */
237 public TreeSet<Package> getLocalAvailableTools() {
238 TreeSet<Package> res = new TreeSet<Package>();
239 for (Package m : tools.values()) {
240 if (m.isLocalAvailable())
241 res.add(m);
242 }
243 return res;
244 }
245
246 /**
247 * @return Tools which can be updated
248 */
249 public TreeSet<Package> getUpdatableTools() {
250 TreeSet<Package> res = new TreeSet<Package>();
251 for (Package m : getLocalAvailableTools()) {
252 if (m.isNewerAvailable())
253 res.add(m);
254 }
255 return res;
256 }
257
258 /**
259 * @return Currently installed tools
260 */
261 public TreeSet<Package> getInstalledTools() {
262 TreeSet<Package> res = new TreeSet<Package>();
[804]263 for (int n : ToolInstallationList.getInstance().getItems().keySet()) {
[1076]264 Package p = getPackageByNumber(n);
265 if (p.isTool()) {
266 res.add(p);
267 }
[648]268 }
269 return res;
270 }
271
272 /**
[860]273 * @return the newToolsOnDepot
274 */
275 public HashMap<Integer, Package> getNewToolsOnDepot() {
276 return newToolsOnDepot;
277 }
278
279 /**
280 * @return the newModsOnDepot
281 */
282 public HashMap<Integer, Package> getNewModsOnDepot() {
283 return newModsOnDepot;
284 }
285
286 /**
[648]287 * Get a mod/tool by its package number
288 *
289 * @param number
290 * Package number
291 * @return Mod/tool or null
292 */
293 private Package getPackageByNumber(int number) {
294 if (mods.containsKey(number))
295 return mods.get(number);
296 if (tools.containsKey(number))
297 return tools.get(number);
298 return null;
299 }
300
301 /**
302 * Check for unresolved dependencies within the given mods
303 *
304 * @param mods
305 * Mods to check
306 * @return Unmet dependencies
307 */
[749]308 public HashMap<Package, HashSet<Package>> checkDependencies(
309 TreeSet<Package> mods) {
[648]310 HashMap<Package, HashSet<Package>> res = new HashMap<Package, HashSet<Package>>();
311
312 for (Package m : mods) {
313 for (int depNum : m.getDependencies()) {
314 Package other = getPackageByNumber(depNum);
[804]315 if (other != null) {
316 if (!mods.contains(other)) {
317 if (!res.containsKey(m))
318 res.put(m, new HashSet<Package>());
319 res.get(m).add(other);
320 }
[648]321 }
322 }
323 }
324
325 return res;
326 }
327
328 /**
329 * Check for incompabitilites between given mods
330 *
331 * @param mods
332 * Mods to check
333 * @return Incompatible mods
334 */
[749]335 public HashMap<Package, HashSet<Package>> checkIncompabitilites(
336 TreeSet<Package> mods) {
[648]337 HashMap<Package, HashSet<Package>> res = new HashMap<Package, HashSet<Package>>();
338
339 for (Package m : mods) {
340 for (int confNum : m.getIncompabitilities()) {
341 Package other = getPackageByNumber(confNum);
[804]342 if (other != null) {
343 if (mods.contains(other)) {
344 if (!res.containsKey(m))
345 res.put(m, new HashSet<Package>());
346 res.get(m).add(other);
347 }
[648]348 }
349 }
350 }
351
352 return res;
353 }
354
355 /**
356 * @param m
357 * Mod to check
358 * @return Is mod installed?
359 */
360 boolean isModInstalled(Package m) {
[857]361 return ModInstallationList.getInstance().isInstalled(
362 m.getPackageNumber());
[648]363 }
[857]364
[859]365 /**
366 * Rescan local packages folder for local only packages and updated
367 * Mod_Info.cfg
368 */
369 public void updateLocalData() {
[857]370 if (Paths.getModsPath().exists()) {
371 for (File f : Paths.getModsPath().listFiles(new FileFilter() {
372 @Override
373 public boolean accept(File pathname) {
374 return pathname.isDirectory();
375 }
376 })) {
377 Package m = new Package(f);
378 HashMap<Integer, Package> map = null;
379 if (m.isTool())
380 map = tools;
381 else
382 map = mods;
383
384 if (!map.containsKey(m.getPackageNumber())) {
385 map.put(m.getPackageNumber(), m);
386 if (!m.isCorePackage()) {
[1001]387 if (m.isTool()) {
388// toolType.addEntry(m);
389// m.getTypes().add(toolType);
390 } else {
391 localType.addEntry(m);
392 m.getTypes().add(localType);
393 }
[857]394 }
395 }
396 }
[863]397 Iterator<Package> it = localType.getEntries().iterator();
398 while (it.hasNext()) {
399 Package p = it.next();
400 if (!p.isLocalAvailable()){
401 it.remove();
402 mods.remove(p.getPackageNumber());
403 tools.remove(p.getPackageNumber());
404 }
405 }
[857]406 }
407
408 for (Package p : mods.values()) {
409 p.updateLocalData();
410 }
411 for (Package p : tools.values()) {
412 p.updateLocalData();
413 }
414 }
415
416 private static XStream getXStream() {
417 XStream xs = new XStream(new StaxDriver());
418 xs.alias("Packages", PackageManager.class);
419 xs.alias("Type", Type.class);
420 xs.alias("Package", Package.class);
421 return xs;
422 }
423
424 /**
425 * Save Depot cache instance to file
426 *
427 * @param cacheFile
428 * File to save to
429 */
430 public void saveToCacheFile(java.io.File cacheFile) {
431 try {
432 FileOutputStream fos = new FileOutputStream(cacheFile);
433 XStream xs = getXStream();
434 xs.toXML(this, fos);
435 fos.close();
436 } catch (FileNotFoundException e) {
437 e.printStackTrace();
438 } catch (IOException e) {
439 e.printStackTrace();
440 }
441 }
442
443 /**
444 * Load cache from file
445 *
446 * @param cacheFile
447 * File to load
448 */
449 public static void loadFromCacheFile(java.io.File cacheFile) {
450 try {
451 FileInputStream fis = new FileInputStream(cacheFile);
[1202]452 Reader reader = new InputStreamReader(fis, "ISO-8859-1");
[857]453 XStream xs = getXStream();
[1202]454 Object obj = xs.fromXML(reader);
[857]455 fis.close();
456 if (obj instanceof PackageManager) {
457 instance = (PackageManager) obj;
458 instance.updateLocalData();
459 }
460 } catch (XStreamException e) {
[1202]461 e.printStackTrace();
[857]462 } catch (FileNotFoundException e) {
463 } catch (IOException e) {
464 }
465 }
[648]466}
Note: See TracBrowser for help on using the repository browser.