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