Source code

001/*
002 * $Id: ServerInfo.java,v 1.15 2011/03/24 16:06:31 davep Exp $
003 *
004 * This file is part of McIDAS-V
005 *
006 * Copyright 2007-2011
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
031package edu.wisc.ssec.mcidasv.chooser;
032
033
034import edu.wisc.ssec.mcidasv.*;
035
036import java.util.ArrayList;
037import java.util.List;
038
039import org.w3c.dom.Document;
040import org.w3c.dom.Element;
041import org.w3c.dom.NodeList;
042
043import ucar.unidata.idv.IntegratedDataViewer;
044import ucar.unidata.idv.IdvResourceManager;
045
046import ucar.unidata.idv.chooser.adde.AddeServer;
047
048import ucar.unidata.xml.XmlResourceCollection;
049import ucar.unidata.xml.XmlUtil;
050
051
052/**
053 * Class ServerInfo Holds has methods for accessing
054 * the contents of servers.xml
055 */
056public 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}