001 /*
002 * $Id: ServerInfo.java,v 1.16 2012/02/19 17:35:36 davep Exp $
003 *
004 * This file is part of McIDAS-V
005 *
006 * Copyright 2007-2012
007 * Space Science and Engineering Center (SSEC)
008 * University of Wisconsin - Madison
009 * 1225 W. Dayton Street, Madison, WI 53706, USA
010 * https://www.ssec.wisc.edu/mcidas
011 *
012 * All Rights Reserved
013 *
014 * McIDAS-V is built on Unidata's IDV and SSEC's VisAD libraries, and
015 * some McIDAS-V source code is based on IDV and VisAD source code.
016 *
017 * McIDAS-V is free software; you can redistribute it and/or modify
018 * it under the terms of the GNU Lesser Public License as published by
019 * the Free Software Foundation; either version 3 of the License, or
020 * (at your option) any later version.
021 *
022 * McIDAS-V is distributed in the hope that it will be useful,
023 * but WITHOUT ANY WARRANTY; without even the implied warranty of
024 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
025 * GNU Lesser Public License for more details.
026 *
027 * You should have received a copy of the GNU Lesser Public License
028 * along with this program. If not, see http://www.gnu.org/licenses.
029 */
030
031 package edu.wisc.ssec.mcidasv.chooser;
032
033
034 import edu.wisc.ssec.mcidasv.*;
035
036 import java.util.ArrayList;
037 import java.util.List;
038
039 import org.w3c.dom.Document;
040 import org.w3c.dom.Element;
041 import org.w3c.dom.NodeList;
042
043 import ucar.unidata.idv.IntegratedDataViewer;
044 import ucar.unidata.idv.IdvResourceManager;
045
046 import ucar.unidata.idv.chooser.adde.AddeServer;
047
048 import ucar.unidata.xml.XmlResourceCollection;
049 import ucar.unidata.xml.XmlUtil;
050
051
052 /**
053 * Class ServerInfo Holds has methods for accessing
054 * the contents of servers.xml
055 */
056 public class ServerInfo {
057
058 private IntegratedDataViewer myIdv;
059
060 /** tags */
061 public static final String TAG_SERVER = "server";
062 public static final String TAG_SERVERS = "servers";
063 public static final String TAG_GROUP = "group";
064
065 /** attributes */
066 public static final String ATTR_ACTIVE = "active";
067 public static final String ATTR_NAME = "name";
068 public static final String ATTR_NAMES = "names";
069 public static final String ATTR_USER = "user";
070 public static final String ATTR_PROJ = "proj";
071 public static final String ATTR_TYPE = "type";
072
073 private XmlResourceCollection serversXRC;
074 private Document serversDocument;
075 private Element serversRoot;
076
077 private static String user = "idv";
078 private static String proj = "0";
079
080 private List typeList = new ArrayList();
081 private List groups = new ArrayList();
082
083 private List serverDescriptors = new ArrayList();
084
085 private String[] defTypes = {"image", "point", "grid", "text", "nav"};
086
087 /**
088 * Constructor
089 */
090 public ServerInfo(IntegratedDataViewer idv, XmlResourceCollection servers) {
091 myIdv = idv;
092 serversXRC = servers;
093
094 if (serversXRC.hasWritableResource()) {
095 serversDocument =
096 serversXRC.getWritableDocument("<servers></servers>");
097 serversRoot =
098 serversXRC.getWritableRoot("<servers></servers>");
099 String tagName = serversRoot.getTagName();
100 }
101 getServersFromXml(serversXRC);
102 }
103
104
105 /**
106 * getServersFromXml
107 * Read and parse servers.xml
108 *
109 * fill lists:
110 * typeList - type name Strings
111 */
112 private void getServersFromXml(XmlResourceCollection servers) {
113 servers.clearCache();
114 serverDescriptors.clear();
115 if (serversXRC.hasWritableResource()) {
116 serversDocument =
117 serversXRC.getWritableDocument("<tabs></tabs>");
118 serversRoot =
119 serversXRC.getWritableRoot("<tabs></tabs>");
120 try {
121 Element root = serversRoot;
122 if (root == null) return;
123 // if ((user.equals("")) && (proj.equals(""))) {
124 if (serversRoot.hasAttribute(ATTR_USER))
125 user = serversRoot.getAttribute(ATTR_USER);
126 if (serversRoot.hasAttribute(ATTR_PROJ))
127 proj = serversRoot.getAttribute(ATTR_PROJ);
128 // }
129 List serverElements = XmlUtil.getElements(root, TAG_SERVER);
130 for (int serverIdx = 0; serverIdx < serverElements.size(); serverIdx++) {
131 Element serverElement = (Element) serverElements.get(serverIdx);
132 String nameServer = XmlUtil.getAttribute(serverElement, ATTR_NAME);
133 String activeServer = XmlUtil.getAttribute(serverElement, ATTR_ACTIVE);
134 List groupElements = XmlUtil.getElements(serverElement, TAG_GROUP);
135 for (int groupIdx = 0; groupIdx < groupElements.size(); groupIdx++) {
136 Element groupElement = (Element) groupElements.get(groupIdx);
137 String activeGroup = XmlUtil.getAttribute(groupElement, ATTR_ACTIVE);
138 String nameGroup = XmlUtil.getAttribute(groupElement, ATTR_NAMES);
139 String type = XmlUtil.getAttribute(groupElement, ATTR_TYPE);
140 if (!typeList.contains(type)) {
141 typeList.add(type);
142 }
143 ServerDescriptor sd =
144 new ServerDescriptor(type, nameServer, nameGroup, activeGroup);
145 serverDescriptors.add(sd);
146 }
147 }
148 } catch (Exception e) {
149 System.out.println("getServersFromXml e=" + e);
150 }
151 }
152 return;
153 }
154
155 /**
156 * getUser
157 * return userId, default="idv"
158 */
159 public String getUser() {
160 return user;
161 }
162
163 /**
164 * getProj
165 * return project number, default="0"
166 */
167 public String getProj() {
168 return proj;
169 }
170
171 public void setUserProj(String user, String proj) {
172 Element serverRoot = serversXRC.getWritableRoot("<tabs></tabs>");
173 Document serverDocument = serversXRC.getWritableDocument("<tabs></tabs>");
174 try {
175 serverRoot.setAttribute(ATTR_USER, user);
176 serverRoot.setAttribute(ATTR_PROJ, proj);
177 serversXRC.setWritableDocument(serverDocument, serverRoot);
178 serversXRC.writeWritable();
179 } catch (Exception e) {
180 System.out.println("updateXml AddeServer.toXml e=" + e);
181 }
182 }
183
184 /**
185 * getServerTypes
186 * return List of type Strings
187 */
188 public List getServerTypes() {
189 for (int i=0; i<defTypes.length; i++) {
190 if (!typeList.contains(defTypes[i])) typeList.add(defTypes[i]);
191 }
192 return typeList;
193 }
194
195 /**
196 * getServers
197 * input: type = data type
198 * all = boolean flag
199 * includeDuplicates = boolean flag
200 * return List of ServerDescriptors
201 */
202 public List getServers(String type, boolean all, boolean includeDuplicates) {
203 init();
204 List servers = new ArrayList();
205 List sds = new ArrayList();
206 groups = new ArrayList();
207 for (int i=0; i<serverDescriptors.size(); i++) {
208 ServerDescriptor sd = (ServerDescriptor)serverDescriptors.get(i);
209 if (sd.isDataType(type)) {
210 String name = sd.getServerName();
211 if (!all) {
212 if (!sd.getIsActive()) continue;
213 if (!includeDuplicates) {
214 if (servers.contains(name)) continue;
215 }
216 }
217 servers.add(name);
218 sds.add(sd);
219 groups.add(sd.getGroupName());
220 }
221 }
222 return sds;
223 }
224
225 /**
226 * getServerNames
227 * input: type = data type
228 * all = boolean flag
229 * includeDuplicates = boolean flag
230 * return List of server name strings
231 */
232 public List getServerNames(String type, boolean all, boolean includeDuplicates) {
233 if (serverDescriptors == null) init();
234 List servers = new ArrayList();
235 if (typeList.contains(type)) {
236 for (int i=0; i<serverDescriptors.size(); i++) {
237 ServerDescriptor sd = (ServerDescriptor)serverDescriptors.get(i);
238 if (sd.isDataType(type)) {
239 String name = sd.getServerName();
240 if (!all) {
241 if (!sd.getIsActive()) continue;
242 if (!includeDuplicates) {
243 if (servers.contains(name)) continue;
244 }
245 }
246 servers.add(name);
247 }
248 }
249 }
250 return servers;
251 }
252
253 /**
254 * getAddeServers
255 * input: type = data type
256 * all = boolean flag
257 * includeDuplicates = boolean flag
258 * return List of server name strings
259 */
260 public List getAddeServers(String type, boolean all, boolean includeDuplicates) {
261 if (serverDescriptors == null) init();
262 List servers = new ArrayList();
263 List names = new ArrayList();
264 if (typeList.contains(type)) {
265 for (int i=0; i<serverDescriptors.size(); i++) {
266 ServerDescriptor sd = (ServerDescriptor)serverDescriptors.get(i);
267 if (sd.isDataType(type)) {
268 String name = sd.getServerName();
269 if (!all) {
270 if (!sd.getIsActive()) continue;
271 }
272 if (!includeDuplicates) {
273 if (names.contains(name)) continue;
274 }
275 AddeServer as = new AddeServer(sd.getServerName());
276 AddeServer.Group g = new AddeServer.Group(sd.getDataType(), sd.getGroupName(), "");
277 g.setActive(sd.getIsActive());
278 as.addGroup(g);
279 servers.add(as);
280 names.add(as.getName());
281 }
282 }
283 }
284 return servers;
285 }
286
287 /**
288 * updateAddeServers(String type, boolean all, boolean includeDuplicates) {
289 * input: type = data type
290 * all = boolean flag
291 * includeDuplicates = boolean flag
292 * return List of server name strings
293 */
294 public List updateAddeServers(String type, boolean all, boolean includeDuplicates) {
295 init();
296 return getAddeServers(type, all, includeDuplicates);
297 }
298
299 /**
300 * init
301 * read servers.xml and initialize all Lists
302 */
303 private boolean init() {
304 serversXRC =
305 myIdv.getResourceManager().getXmlResources(
306 IdvResourceManager.RSC_ADDESERVER);
307 getServersFromXml(serversXRC);
308 if (serverDescriptors == null) return false;
309 return true;
310 }
311
312 /**
313 * getGroups - return all groups for a given data type
314 * return List of group name Strings
315 */
316 public List getGroups(String type) {
317 init();
318 getServers(type, false, true);
319 return groups;
320 }
321
322
323 /**
324 * addServers to servers.xml
325 * input: type = data type
326 * serverList = alternating strings: name1, group1, name2, group2, etc.
327 */
328 public void addServers(IntegratedDataViewer idv, List serverList) {
329 int num = serverList.size();
330 List addeServers = new ArrayList();
331 if (num > 0) {
332 try {
333 for (int i=0; i<num; i++) {
334 ServerDescriptor sd = (ServerDescriptor) serverList.get(i);
335 String servName = sd.getServerName();
336 AddeServer as = new AddeServer(sd.getServerName());
337 AddeServer.Group g = new AddeServer.Group(sd.getDataType(), sd.getGroupName(), "");
338 g.setActive(sd.getIsActive());
339 as.addGroup(g);
340 addeServers.add(as);
341 }
342 } catch (Exception e) {
343 System.out.println("addServers e=" + e);
344 };
345 }
346 List serversFinal = AddeServer.coalesce(addeServers);
347
348 XmlResourceCollection serverCollection =
349 idv.getResourceManager().getXmlResources(
350 IdvResourceManager.RSC_ADDESERVER);
351 Element serverRoot = serverCollection.getWritableRoot("<tabs></tabs>");
352 Document serverDocument = serverCollection.getWritableDocument("<tabs></tabs>");
353 try {
354 Element serversEle = AddeServer.toXml(serversFinal, false);
355 serverCollection.setWritableDocument(serverDocument, serversEle);
356 serverCollection.writeWritable();
357 } catch (Exception e) {
358 System.out.println("AddeServer.toXml e=" + e);
359 }
360 }
361
362 /**
363 * Clear servers.xml
364 */
365 public void clear(XmlResourceCollection serversXRC) {
366 List typeElements = XmlUtil.getElements(serversRoot, TAG_SERVER);
367 for (int typeIdx = 0; typeIdx < typeElements.size(); typeIdx++) {
368 Element typeElement = (Element) typeElements.get(typeIdx);
369 XmlUtil.removeChildren(typeElement);
370 }
371 try {
372 serversXRC.writeWritable();
373 } catch (Exception e) {
374 }
375 serversXRC.setWritableDocument(serversDocument, serversRoot);
376 }
377 }