oni2/moddepot/DepotManager.java

package net.oni2.moddepot;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.net.UnknownHostException;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Vector;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;

import net.oni2.moddepot.model.File;
import net.oni2.moddepot.model.Node;
import net.oni2.moddepot.model.NodeField_Body;
import net.oni2.moddepot.model.NodeField_Upload;
import net.oni2.moddepot.model.NodeMod;
import net.oni2.moddepot.model.TaxonomyTerm;
import net.oni2.moddepot.model.TaxonomyVocabulary;
import net.oni2.httpfiledownloader.FileDownloader;

import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpHead;
import org.apache.http.client.methods.HttpRequestBase;
import org.apache.http.impl.client.DefaultHttpClient;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.XStreamException;
import com.thoughtworks.xstream.io.xml.StaxDriver;

/**
 * @author Christian Illy
 */
public class DepotManager {
        private static DepotManager instance = null;

        private HashMap<Integer, TaxonomyVocabulary> taxonomyVocabulary = new HashMap<Integer, TaxonomyVocabulary>();
        private HashMap<Integer, TaxonomyTerm> taxonomyTerms = new HashMap<Integer, TaxonomyTerm>();

        private HashMap<Integer, Node> nodes = new HashMap<Integer, Node>();
        private HashMap<String, HashMap<Integer, Node>> nodesByType = new HashMap<String, HashMap<Integer, Node>>();

        private HashMap<Integer, File> files = new HashMap<Integer, File>();

        /**
         * Caching the vocab id for the package type vocabulary
         */
        public int vocabId_type = -1;
        /**
         * Caching the vocab id for the platform vocabulary
         */
        public int vocabId_platform = -1;
        /**
         * Caching the vocab id for the install method vocabulary
         */
        public int vocabId_instmethod = -1;

        /**
         * @return Singleton instance
         */
        public static DepotManager getInstance() {
                if (instance == null)
                        instance = new DepotManager();
                return instance;
        }

        /**
         * Update local Depot information cache
         * 
         * @return Update successfully done?
         */
        public boolean updateInformation() {
                try {
                        java.io.File zipName = new java.io.File(
                                        System.getProperty("java.io.tmpdir"), "aei_jsoncache.zip");
                        FileDownloader fd = new FileDownloader(DepotConfig.depotUrl
                                        + "jsoncache/jsoncache.zip?ts="
                                        + (new Date().getTime() / 1000), zipName);
                        fd.start();
                        while (fd.getState() != FileDownloader.EState.FINISHED) {
                                Thread.sleep(50);
                        }

                        String jsonVocab = null;
                        String jsonTerms = null;
                        String jsonNodes = null;
                        String jsonFiles = null;

                        ZipFile zf = null;
                        try {
                                zf = new ZipFile(zipName);

                                for (Enumeration<? extends ZipEntry> e = zf.entries(); e
                                                .hasMoreElements();) {
                                        ZipEntry ze = e.nextElement();
                                        if (!ze.isDirectory()) {
                                                BufferedReader input = new BufferedReader(
                                                                new InputStreamReader(zf.getInputStream(ze)));
                                                StringBuffer json = new StringBuffer();

                                                char data[] = new char[1024];
                                                int dataRead;
                                                while ((dataRead = input.read(data, 0, 1024)) != -1) {
                                                        json.append(data, 0, dataRead);
                                                }

                                                if (ze.getName().toLowerCase().contains("vocabulary"))
                                                        jsonVocab = json.toString();
                                                if (ze.getName().toLowerCase().contains("terms"))
                                                        jsonTerms = json.toString();
                                                if (ze.getName().toLowerCase().contains("nodes"))
                                                        jsonNodes = json.toString();
                                                if (ze.getName().toLowerCase().contains("files"))
                                                        jsonFiles = json.toString();
                                        }
                                }
                        } finally {
                                if (zf != null)
                                        zf.close();
                                zipName.delete();
                        }

                        initVocabulary(new JSONArray(jsonVocab));

                        vocabId_type = getVocabulary(DepotConfig.vocabName_ModType)
                                        .getVid();
                        vocabId_platform = getVocabulary(DepotConfig.vocabName_Platform)
                                        .getVid();
                        vocabId_instmethod = getVocabulary(
                                        DepotConfig.vocabName_InstallType).getVid();

                        initTerms(new JSONArray(jsonTerms));
                        initFiles(new JSONArray(jsonFiles));
                        initNodes(new JSONArray(jsonNodes));

                        return true;
                } catch (JSONException e) {
                        e.printStackTrace();
                } catch (IOException e1) {
                        e1.printStackTrace();
                } catch (InterruptedException e) {
                        e.printStackTrace();
                }
                return false;
        }

        private void initFiles(JSONArray ja) throws JSONException {
                files = new HashMap<Integer, File>();
                JSONObject jo;
                for (int i = 0; i < ja.length(); i++) {
                        jo = ja.getJSONObject(i);
                        int fid = jo.getInt("fid");

                        File f = new File(jo);
                        files.put(fid, f);
                }
        }

        private void initNodes(JSONArray ja) throws JSONException {
                nodes = new HashMap<Integer, Node>();
                nodesByType = new HashMap<String, HashMap<Integer, Node>>();
                JSONObject jo;
                for (int i = 0; i < ja.length(); i++) {
                        jo = ja.getJSONObject(i);

                        int nid = jo.getInt("nid");
                        String type = jo.getString("type");

                        Node n = null;
                        if (type.equalsIgnoreCase(DepotConfig.nodeType_Package))
                                n = new NodeMod(jo);
                        else
                                n = new Node(jo);

                        if (n.getStatus() > 0) {
                                nodes.put(nid, n);
                                if (!nodesByType.containsKey(type))
                                        nodesByType.put(type, new HashMap<Integer, Node>());
                                nodesByType.get(type).put(nid, n);
                        }
                }
        }

        private void initTerms(JSONArray ja) throws JSONException {
                taxonomyTerms.clear();
                JSONObject jo;
                for (int i = 0; i < ja.length(); i++) {
                        jo = ja.getJSONObject(i);
                        TaxonomyTerm tt = new TaxonomyTerm(jo);
                        taxonomyTerms.put(tt.getTid(), tt);
                }
        }

        private void initVocabulary(JSONArray ja) throws JSONException {
                taxonomyVocabulary.clear();
                JSONObject jo;
                for (int i = 0; i < ja.length(); i++) {
                        jo = ja.getJSONObject(i);
                        TaxonomyVocabulary tv = new TaxonomyVocabulary(jo);
                        taxonomyVocabulary.put(tv.getVid(), tv);
                }
        }

        /**
         * @return Can we connect to the Depot?
         */
        public boolean checkConnection() {
                HttpRequestBase httpQuery = null;

                try {
                        DefaultHttpClient httpclient = new DefaultHttpClient();
                        httpQuery = new HttpHead(DepotConfig.depotUrl);
                        HttpResponse response = httpclient.execute(httpQuery);
                        int code = response.getStatusLine().getStatusCode();
                        return (code >= 200) && (code <= 299);
                } catch (UnknownHostException e) {
                } catch (UnsupportedEncodingException e) {
                        e.printStackTrace();
                } catch (IOException e) {
                        e.printStackTrace();
                } finally {
                        if (httpQuery != null)
                                httpQuery.releaseConnection();
                }
                return false;
        }

        private TaxonomyVocabulary getVocabulary(String name) {
                for (TaxonomyVocabulary v : taxonomyVocabulary.values()) {
                        if (v.getName().equalsIgnoreCase(name))
                                return v;
                }
                return null;
        }

        /**
         * @param vocabId
         *            Get all taxonomy terms of a given vocabulary
         * @return TaxTerms
         */
        private Vector<TaxonomyTerm> getTaxonomyTermsByVocabulary(int vocabId) {
                Vector<TaxonomyTerm> res = new Vector<TaxonomyTerm>();
                for (TaxonomyTerm t : taxonomyTerms.values()) {
                        if (t.getVid() == vocabId)
                                res.add(t);
                }
                return res;
        }

        /**
         * @return All defined types
         */
        public Vector<TaxonomyTerm> getTypes() {
                return getTaxonomyTermsByVocabulary(vocabId_type);
        }

        /**
         * @param id
         *            Get taxonomy term by given ID
         * @return TaxTerm
         */
        public TaxonomyTerm getTaxonomyTerm(int id) {
                return taxonomyTerms.get(id);
        }

        /**
         * Get all nodes of given node type
         * 
         * @param nodeType
         *            Node type
         * @return Nodes of type nodeType
         */
        public Vector<Node> getNodesByType(String nodeType) {
                if (nodesByType.get(nodeType) == null)
                        return new Vector<Node>();
                return new Vector<Node>(nodesByType.get(nodeType).values());
        }

        /**
         * @return Mod-Nodes
         */
        public Vector<NodeMod> getModPackageNodes() {
                Vector<NodeMod> result = new Vector<NodeMod>();
                String instMethName = DepotConfig.taxName_InstallType_Package;

                Vector<Node> files = getNodesByType(DepotConfig.nodeType_Package);
                for (Node n : files) {
                        if (n instanceof NodeMod) {
                                NodeMod nm = (NodeMod) n;
                                if (nm.getInstallMethod().equalsIgnoreCase(instMethName)) {
                                        if (nm.getPackageNumber() >= 0)
                                                result.add(nm);
                                        else
                                                System.err.println("Node " + nm.getNid()
                                                                + " does not have a package number!!!");
                                }
                        }
                }
                return result;
        }

        /**
         * @param id
         *            ID of file to get
         * @return the file
         */
        public File getFile(int id) {
                return files.get(id);
        }

        private static XStream getXStream() {
                XStream xs = new XStream(new StaxDriver());
                xs.alias("Depot", DepotManager.class);
                xs.alias("File", net.oni2.moddepot.model.File.class);
                xs.alias("Node", Node.class);
                xs.alias("NodeField_Body", NodeField_Body.class);
                xs.alias("NodeField_Upload", NodeField_Upload.class);
                xs.alias("NodeMod", NodeMod.class);
                xs.alias("TaxonomyTerm", TaxonomyTerm.class);
                xs.alias("TaxonomyVocabulary", TaxonomyVocabulary.class);
                return xs;
        }

        /**
         * Save Depot cache instance to file
         * 
         * @param cacheFile
         *            File to save to
         */
        public void saveToCacheFile(java.io.File cacheFile) {
                try {
                        FileOutputStream fos = new FileOutputStream(cacheFile);
                        XStream xs = getXStream();
                        xs.toXML(this, fos);
                        fos.close();
                } catch (FileNotFoundException e) {
                        e.printStackTrace();
                } catch (IOException e) {
                        e.printStackTrace();
                }
        }

        /**
         * Load cache from file
         * 
         * @param cacheFile
         *            File to load
         */
        public static void loadFromCacheFile(java.io.File cacheFile) {
                try {
                        FileInputStream fis = new FileInputStream(cacheFile);
                        XStream xs = getXStream();
                        Object obj = xs.fromXML(fis);
                        fis.close();
                        if (obj instanceof DepotManager)
                                instance = (DepotManager) obj;
                } catch (XStreamException e) {
                } catch (FileNotFoundException e) {
                } catch (IOException e) {
                }
        }
}
Revision:	748
Committed:	Tue Mar 26 17:24:53 2013 UTC (12 years, 6 months ago) by alloc
Content type:	text/x-java
File size:	10006 byte(s)
Log Message:	java lib: Mod depot access
#	Content
1	package net.oni2.moddepot;
2
3	import java.io.BufferedReader;
4	import java.io.FileInputStream;
5	import java.io.FileNotFoundException;
6	import java.io.FileOutputStream;
7	import java.io.IOException;
8	import java.io.InputStreamReader;
9	import java.io.UnsupportedEncodingException;
10	import java.net.UnknownHostException;
11	import java.util.Date;
12	import java.util.Enumeration;
13	import java.util.HashMap;
14	import java.util.Vector;
15	import java.util.zip.ZipEntry;
16	import java.util.zip.ZipFile;
17
18	import net.oni2.moddepot.model.File;
19	import net.oni2.moddepot.model.Node;
20	import net.oni2.moddepot.model.NodeField_Body;
21	import net.oni2.moddepot.model.NodeField_Upload;
22	import net.oni2.moddepot.model.NodeMod;
23	import net.oni2.moddepot.model.TaxonomyTerm;
24	import net.oni2.moddepot.model.TaxonomyVocabulary;
25	import net.oni2.httpfiledownloader.FileDownloader;
26
27	import org.apache.http.HttpResponse;
28	import org.apache.http.client.methods.HttpHead;
29	import org.apache.http.client.methods.HttpRequestBase;
30	import org.apache.http.impl.client.DefaultHttpClient;
31	import org.json.JSONArray;
32	import org.json.JSONException;
33	import org.json.JSONObject;
34
35	import com.thoughtworks.xstream.XStream;
36	import com.thoughtworks.xstream.XStreamException;
37	import com.thoughtworks.xstream.io.xml.StaxDriver;
38
39	/**
40	* @author Christian Illy
41	*/
42	public class DepotManager {
43	private static DepotManager instance = null;
44
45	private HashMap<Integer, TaxonomyVocabulary> taxonomyVocabulary = new HashMap<Integer, TaxonomyVocabulary>();
46	private HashMap<Integer, TaxonomyTerm> taxonomyTerms = new HashMap<Integer, TaxonomyTerm>();
47
48	private HashMap<Integer, Node> nodes = new HashMap<Integer, Node>();
49	private HashMap<String, HashMap<Integer, Node>> nodesByType = new HashMap<String, HashMap<Integer, Node>>();
50
51	private HashMap<Integer, File> files = new HashMap<Integer, File>();
52
53	/**
54	* Caching the vocab id for the package type vocabulary
55	*/
56	public int vocabId_type = -1;
57	/**
58	* Caching the vocab id for the platform vocabulary
59	*/
60	public int vocabId_platform = -1;
61	/**
62	* Caching the vocab id for the install method vocabulary
63	*/
64	public int vocabId_instmethod = -1;
65
66	/**
67	* @return Singleton instance
68	*/
69	public static DepotManager getInstance() {
70	if (instance == null)
71	instance = new DepotManager();
72	return instance;
73	}
74
75	/**
76	* Update local Depot information cache
77	*
78	* @return Update successfully done?
79	*/
80	public boolean updateInformation() {
81	try {
82	java.io.File zipName = new java.io.File(
83	System.getProperty("java.io.tmpdir"), "aei_jsoncache.zip");
84	FileDownloader fd = new FileDownloader(DepotConfig.depotUrl
85	+ "jsoncache/jsoncache.zip?ts="
86	+ (new Date().getTime() / 1000), zipName);
87	fd.start();
88	while (fd.getState() != FileDownloader.EState.FINISHED) {
89	Thread.sleep(50);
90	}
91
92	String jsonVocab = null;
93	String jsonTerms = null;
94	String jsonNodes = null;
95	String jsonFiles = null;
96
97	ZipFile zf = null;
98	try {
99	zf = new ZipFile(zipName);
100
101	for (Enumeration<? extends ZipEntry> e = zf.entries(); e
102	.hasMoreElements();) {
103	ZipEntry ze = e.nextElement();
104	if (!ze.isDirectory()) {
105	BufferedReader input = new BufferedReader(
106	new InputStreamReader(zf.getInputStream(ze)));
107	StringBuffer json = new StringBuffer();
108
109	char data[] = new char[1024];
110	int dataRead;
111	while ((dataRead = input.read(data, 0, 1024)) != -1) {
112	json.append(data, 0, dataRead);
113	}
114
115	if (ze.getName().toLowerCase().contains("vocabulary"))
116	jsonVocab = json.toString();
117	if (ze.getName().toLowerCase().contains("terms"))
118	jsonTerms = json.toString();
119	if (ze.getName().toLowerCase().contains("nodes"))
120	jsonNodes = json.toString();
121	if (ze.getName().toLowerCase().contains("files"))
122	jsonFiles = json.toString();
123	}
124	}
125	} finally {
126	if (zf != null)
127	zf.close();
128	zipName.delete();
129	}
130
131	initVocabulary(new JSONArray(jsonVocab));
132
133	vocabId_type = getVocabulary(DepotConfig.vocabName_ModType)
134	.getVid();
135	vocabId_platform = getVocabulary(DepotConfig.vocabName_Platform)
136	.getVid();
137	vocabId_instmethod = getVocabulary(
138	DepotConfig.vocabName_InstallType).getVid();
139
140	initTerms(new JSONArray(jsonTerms));
141	initFiles(new JSONArray(jsonFiles));
142	initNodes(new JSONArray(jsonNodes));
143
144	return true;
145	} catch (JSONException e) {
146	e.printStackTrace();
147	} catch (IOException e1) {
148	e1.printStackTrace();
149	} catch (InterruptedException e) {
150	e.printStackTrace();
151	}
152	return false;
153	}
154
155	private void initFiles(JSONArray ja) throws JSONException {
156	files = new HashMap<Integer, File>();
157	JSONObject jo;
158	for (int i = 0; i < ja.length(); i++) {
159	jo = ja.getJSONObject(i);
160	int fid = jo.getInt("fid");
161
162	File f = new File(jo);
163	files.put(fid, f);
164	}
165	}
166
167	private void initNodes(JSONArray ja) throws JSONException {
168	nodes = new HashMap<Integer, Node>();
169	nodesByType = new HashMap<String, HashMap<Integer, Node>>();
170	JSONObject jo;
171	for (int i = 0; i < ja.length(); i++) {
172	jo = ja.getJSONObject(i);
173
174	int nid = jo.getInt("nid");
175	String type = jo.getString("type");
176
177	Node n = null;
178	if (type.equalsIgnoreCase(DepotConfig.nodeType_Package))
179	n = new NodeMod(jo);
180	else
181	n = new Node(jo);
182
183	if (n.getStatus() > 0) {
184	nodes.put(nid, n);
185	if (!nodesByType.containsKey(type))
186	nodesByType.put(type, new HashMap<Integer, Node>());
187	nodesByType.get(type).put(nid, n);
188	}
189	}
190	}
191
192	private void initTerms(JSONArray ja) throws JSONException {
193	taxonomyTerms.clear();
194	JSONObject jo;
195	for (int i = 0; i < ja.length(); i++) {
196	jo = ja.getJSONObject(i);
197	TaxonomyTerm tt = new TaxonomyTerm(jo);
198	taxonomyTerms.put(tt.getTid(), tt);
199	}
200	}
201
202	private void initVocabulary(JSONArray ja) throws JSONException {
203	taxonomyVocabulary.clear();
204	JSONObject jo;
205	for (int i = 0; i < ja.length(); i++) {
206	jo = ja.getJSONObject(i);
207	TaxonomyVocabulary tv = new TaxonomyVocabulary(jo);
208	taxonomyVocabulary.put(tv.getVid(), tv);
209	}
210	}
211
212	/**
213	* @return Can we connect to the Depot?
214	*/
215	public boolean checkConnection() {
216	HttpRequestBase httpQuery = null;
217
218	try {
219	DefaultHttpClient httpclient = new DefaultHttpClient();
220	httpQuery = new HttpHead(DepotConfig.depotUrl);
221	HttpResponse response = httpclient.execute(httpQuery);
222	int code = response.getStatusLine().getStatusCode();
223	return (code >= 200) && (code <= 299);
224	} catch (UnknownHostException e) {
225	} catch (UnsupportedEncodingException e) {
226	e.printStackTrace();
227	} catch (IOException e) {
228	e.printStackTrace();
229	} finally {
230	if (httpQuery != null)
231	httpQuery.releaseConnection();
232	}
233	return false;
234	}
235
236	private TaxonomyVocabulary getVocabulary(String name) {
237	for (TaxonomyVocabulary v : taxonomyVocabulary.values()) {
238	if (v.getName().equalsIgnoreCase(name))
239	return v;
240	}
241	return null;
242	}
243
244	/**
245	* @param vocabId
246	* Get all taxonomy terms of a given vocabulary
247	* @return TaxTerms
248	*/
249	private Vector<TaxonomyTerm> getTaxonomyTermsByVocabulary(int vocabId) {
250	Vector<TaxonomyTerm> res = new Vector<TaxonomyTerm>();
251	for (TaxonomyTerm t : taxonomyTerms.values()) {
252	if (t.getVid() == vocabId)
253	res.add(t);
254	}
255	return res;
256	}
257
258	/**
259	* @return All defined types
260	*/
261	public Vector<TaxonomyTerm> getTypes() {
262	return getTaxonomyTermsByVocabulary(vocabId_type);
263	}
264
265	/**
266	* @param id
267	* Get taxonomy term by given ID
268	* @return TaxTerm
269	*/
270	public TaxonomyTerm getTaxonomyTerm(int id) {
271	return taxonomyTerms.get(id);
272	}
273
274	/**
275	* Get all nodes of given node type
276	*
277	* @param nodeType
278	* Node type
279	* @return Nodes of type nodeType
280	*/
281	public Vector<Node> getNodesByType(String nodeType) {
282	if (nodesByType.get(nodeType) == null)
283	return new Vector<Node>();
284	return new Vector<Node>(nodesByType.get(nodeType).values());
285	}
286
287	/**
288	* @return Mod-Nodes
289	*/
290	public Vector<NodeMod> getModPackageNodes() {
291	Vector<NodeMod> result = new Vector<NodeMod>();
292	String instMethName = DepotConfig.taxName_InstallType_Package;
293
294	Vector<Node> files = getNodesByType(DepotConfig.nodeType_Package);
295	for (Node n : files) {
296	if (n instanceof NodeMod) {
297	NodeMod nm = (NodeMod) n;
298	if (nm.getInstallMethod().equalsIgnoreCase(instMethName)) {
299	if (nm.getPackageNumber() >= 0)
300	result.add(nm);
301	else
302	System.err.println("Node " + nm.getNid()
303	+ " does not have a package number!!!");
304	}
305	}
306	}
307	return result;
308	}
309
310	/**
311	* @param id
312	* ID of file to get
313	* @return the file
314	*/
315	public File getFile(int id) {
316	return files.get(id);
317	}
318
319	private static XStream getXStream() {
320	XStream xs = new XStream(new StaxDriver());
321	xs.alias("Depot", DepotManager.class);
322	xs.alias("File", net.oni2.moddepot.model.File.class);
323	xs.alias("Node", Node.class);
324	xs.alias("NodeField_Body", NodeField_Body.class);
325	xs.alias("NodeField_Upload", NodeField_Upload.class);
326	xs.alias("NodeMod", NodeMod.class);
327	xs.alias("TaxonomyTerm", TaxonomyTerm.class);
328	xs.alias("TaxonomyVocabulary", TaxonomyVocabulary.class);
329	return xs;
330	}
331
332	/**
333	* Save Depot cache instance to file
334	*
335	* @param cacheFile
336	* File to save to
337	*/
338	public void saveToCacheFile(java.io.File cacheFile) {
339	try {
340	FileOutputStream fos = new FileOutputStream(cacheFile);
341	XStream xs = getXStream();
342	xs.toXML(this, fos);
343	fos.close();
344	} catch (FileNotFoundException e) {
345	e.printStackTrace();
346	} catch (IOException e) {
347	e.printStackTrace();
348	}
349	}
350
351	/**
352	* Load cache from file
353	*
354	* @param cacheFile
355	* File to load
356	*/
357	public static void loadFromCacheFile(java.io.File cacheFile) {
358	try {
359	FileInputStream fis = new FileInputStream(cacheFile);
360	XStream xs = getXStream();
361	Object obj = xs.fromXML(fis);
362	fis.close();
363	if (obj instanceof DepotManager)
364	instance = (DepotManager) obj;
365	} catch (XStreamException e) {
366	} catch (FileNotFoundException e) {
367	} catch (IOException e) {
368	}
369	}
370	}