source: main/trunk/greenstone3/src/java/org/greenstone/gsdl3/collection/ServiceCluster.java@ 25635

Last change on this file since 25635 was 25635, checked in by sjm84, 12 years ago

Fixing Greenstone 3's use (or lack thereof) of generics, this was done automatically so we may want to change it over time. This change will also auto-format any files that have not already been formatted.
  • Property svn:keywords set to Author Date Id Revision
File size: 28.2 KB
Line 
1/*
2 * ServiceCluster.java
3 * Copyright (C) 2002 New Zealand Digital Library, http://www.nzdl.org
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 */
19// leave the package name as is for now - should be changed to something better
20// cluster? groups?
21package org.greenstone.gsdl3.collection;
22
23import org.greenstone.gsdl3.util.*;
24import org.greenstone.gsdl3.core.*;
25import org.greenstone.gsdl3.service.*;
26
27// java XML classes we're using
28import org.w3c.dom.Document;
29import org.w3c.dom.Node;
30import org.w3c.dom.Element;
31import org.w3c.dom.NodeList;
32
33import java.io.*;
34import java.util.HashMap;
35import java.util.Iterator;
36
37import org.apache.log4j.*;
38
39/* ServiceCluster - a groups of services that are related in some way
40 * Implements ModuleInterface. Contains a list of services provided by the cluster, along with metadata about the cluster itself.
41 * a collection is a special type of cluster
42 * @author <a href="mailto:[email protected]">Katherine Don</a>
43 * @version $Revision: 25635 $
44 * @see ModuleInterface
45 */
46public class ServiceCluster implements ModuleInterface
47{
48
49 static Logger logger = Logger.getLogger(org.greenstone.gsdl3.collection.ServiceCluster.class.getName());
50
51 protected static final String CONFIG_ENCODING = "utf-8";
52
53 protected static final String DEFAULT_LANG = "en"; // hack for now, should be read from the coll cfg file? or site cfg file for cluster
54
55 /** base directory for the site that this cluster belongs to */
56 protected String site_home = null;
57 /** http address of the site that this cluster belongs to */
58 protected String site_http_address = null;
59 /** The name of the cluster - for a collection, this is the collection name */
60 protected String cluster_name = null;
61 /** collection type : mg, mgpp or lucene */
62 protected String col_type = "";
63 /** database type : gdbm, jdbm or sqlite */
64 protected String db_type = "";
65
66 /** a reference to the message router */
67 protected MessageRouter router = null;
68 /**
69 * The map of services.
70 *
71 * Maps Services to ServiceRack objects
72 *
73 * @see ServiceRack
74 *
75 */
76 protected HashMap<String, ServiceRack> service_map = null;
77 /**
78 * maps pseudo service names to real service names - needed if we have two
79 * services with the same name for one collection
80 */
81 protected HashMap<String, String> service_name_map = null;
82
83 /** XML converter for String to DOM and vice versa */
84 protected XMLConverter converter = null;
85
86 /** container doc for description elements */
87 protected Document doc = null;
88 /** list of services */
89 protected Element service_list = null;
90 /** list of metadata - all metadata, regardless of language goes in here */
91 protected Element metadata_list = null;
92 /** language specific stuff */
93 //protected Element lang_specific_metadata_list = null;
94 protected Element display_item_list = null;
95 /** the element that will have any descriptions passed back in */
96 protected Element description = null;
97
98 /** list of plugin */
99 protected Element plugin_item_list = null;
100
101 public void setSiteHome(String home)
102 {
103 this.site_home = home;
104 }
105
106 public void setSiteAddress(String address)
107 {
108 this.site_http_address = address;
109 }
110
111 public void cleanUp()
112 {
113 Iterator<ServiceRack> i = this.service_map.values().iterator();
114 while (i.hasNext())
115 {
116 ServiceRack s = i.next();
117 s.cleanUp();
118 }
119 }
120
121 public void setClusterName(String name)
122 {
123 this.cluster_name = name;
124 this.description.setAttribute(GSXML.NAME_ATT, name);
125 }
126
127 public void setMessageRouter(MessageRouter m)
128 {
129 this.router = m;
130 }
131
132 public ServiceCluster()
133 {
134 this.service_map = new HashMap<String, ServiceRack>();
135 this.service_name_map = new HashMap<String, String>();
136 this.converter = new XMLConverter();
137 this.doc = this.converter.newDOM();
138 this.description = this.doc.createElement(GSXML.CLUSTER_ELEM);
139 this.display_item_list = this.doc.createElement(GSXML.DISPLAY_TEXT_ELEM + GSXML.LIST_MODIFIER);
140 this.metadata_list = this.doc.createElement(GSXML.METADATA_ELEM + GSXML.LIST_MODIFIER);
141 this.plugin_item_list = this.doc.createElement(GSXML.PLUGIN_ELEM + GSXML.LIST_MODIFIER);
142 }
143
144 /**
145 * Configures the cluster.
146 *
147 * gsdlHome and clusterName must be set before configure is called.
148 *
149 * reads the site configuration file, and configures itself this calls
150 * configure(Element) with the XML element node from the config file.
151 * configure(Element) should be used if the config file has already been
152 * parsed. This method will work with any subclass.
153 *
154 * @return true if configure successful, false otherwise.
155 */
156 public boolean configure()
157 {
158
159 if (this.site_home == null || this.cluster_name == null)
160 {
161 logger.error("site_home and cluster_name must be set before configure called!");
162 return false;
163 }
164 logger.info("configuring service cluster");
165 // read the site configuration file
166 File config_file = new File(GSFile.siteConfigFile(this.site_home));
167
168 if (!config_file.exists())
169 {
170 logger.error("couldn't configure cluster: " + this.cluster_name + ", " + config_file + " does not exist");
171 return false;
172 }
173
174 Document doc = this.converter.getDOM(config_file, CONFIG_ENCODING);
175 if (doc == null)
176 {
177 logger.error("couldn't parse config file " + config_file.getPath());
178 return false;
179 }
180
181 // get the appropriate service cluster element
182 Element cluster_list = (Element) GSXML.getChildByTagName(doc.getDocumentElement(), GSXML.CLUSTER_ELEM + GSXML.LIST_MODIFIER);
183 Element sc = GSXML.getNamedElement(cluster_list, GSXML.CLUSTER_ELEM, GSXML.NAME_ATT, this.cluster_name);
184
185 return this.configure(sc);
186 }
187
188 public boolean configure(Element service_cluster_info)
189 {
190
191 // get the metadata - for now just add it to the list
192 Element meta_list = (Element) GSXML.getChildByTagName(service_cluster_info, GSXML.METADATA_ELEM + GSXML.LIST_MODIFIER);
193 if (meta_list != null)
194 {
195 if (!addMetadata(meta_list))
196 {
197
198 logger.error(" couldn't configure the metadata");
199 }
200 }
201
202 // get the display info
203 Element display_list = (Element) GSXML.getChildByTagName(service_cluster_info, GSXML.DISPLAY_TEXT_ELEM + GSXML.LIST_MODIFIER);
204 if (display_list != null)
205 {
206 if (!addDisplayItems(display_list))
207 {
208
209 logger.error("couldn't configure the display items");
210 }
211 }
212
213 //get the plugin info
214 Element import_list = (Element) GSXML.getChildByTagName(service_cluster_info, GSXML.IMPORT_ELEM);
215 if (import_list != null)
216 {
217 Element plugin_list = (Element) GSXML.getChildByTagName(service_cluster_info, GSXML.PLUGIN_ELEM + GSXML.LIST_MODIFIER);
218 if (plugin_list != null)
219 {
220 if (!addPlugins(plugin_list))
221 {
222
223 logger.error("couldn't configure the plugins");
224 }
225 }
226 }
227
228 // do the service racks
229 // empty the service map in case this is a reconfigure
230 clearServices();
231 Element service_rack_list = (Element) GSXML.getChildByTagName(service_cluster_info, GSXML.SERVICE_CLASS_ELEM + GSXML.LIST_MODIFIER);
232 if (service_rack_list == null)
233 {
234 // is this an error? could you ever have a service cluster
235 // without service racks???
236 logger.error("cluster has no service racks!!");
237 }
238 else
239 {
240
241 if (!configureServiceRackList(service_rack_list, null))
242 {
243 logger.error("couldn't configure the service racks!!");
244 return false;
245 }
246 }
247
248 return true;
249 }
250
251 /**
252 * adds metadata from a metadataList into the metadata_list xml
253 */
254 protected boolean addMetadata(Element metadata_list)
255 {
256 if (metadata_list == null)
257 return false;
258 NodeList metanodes = metadata_list.getElementsByTagName(GSXML.METADATA_ELEM);
259 if (metanodes.getLength() > 0)
260 {
261 for (int k = 0; k < metanodes.getLength(); k++)
262 {
263 this.metadata_list.appendChild(this.doc.importNode(metanodes.item(k), true));
264 }
265 }
266
267 return true;
268 }
269
270 protected boolean addDisplayItems(Element display_list)
271 {
272
273 if (display_list == null)
274 return false;
275 NodeList displaynodes = display_list.getElementsByTagName(GSXML.DISPLAY_TEXT_ELEM);
276 if (displaynodes.getLength() > 0)
277 {
278 for (int k = 0; k < displaynodes.getLength(); k++)
279 {
280 Element d = (Element) displaynodes.item(k);
281 String lang = d.getAttribute(GSXML.LANG_ATT);
282 if (lang == null || lang.equals(""))
283 {
284 //set the lang to teh default
285 d.setAttribute(GSXML.LANG_ATT, DEFAULT_LANG);
286 }
287 String name = d.getAttribute(GSXML.NAME_ATT);
288 Element this_item = GSXML.getNamedElement(this.display_item_list, GSXML.DISPLAY_TEXT_ELEM, GSXML.NAME_ATT, name);
289 if (this_item == null)
290 {
291 this_item = this.doc.createElement(GSXML.DISPLAY_TEXT_ELEM);
292 this_item.setAttribute(GSXML.NAME_ATT, name);
293 this.display_item_list.appendChild(this_item);
294 }
295
296 this_item.appendChild(this.doc.importNode(d, true));
297 }
298 }
299
300 return true;
301 }
302
303 protected boolean addPlugins(Element plugin_list)
304 {
305 if (plugin_list == null)
306 return false;
307 NodeList pluginNodes = plugin_list.getElementsByTagName(GSXML.PLUGIN_ELEM);
308 if (pluginNodes.getLength() > 0)
309 {
310 for (int k = 0; k < pluginNodes.getLength(); k++)
311 {
312 this.plugin_item_list.appendChild(this.doc.importNode(pluginNodes.item(k), true));
313 }
314 }
315
316 return true;
317 }
318
319 protected void clearServices()
320 {
321 service_map.clear();
322 this.service_list = this.doc.createElement(GSXML.SERVICE_ELEM + GSXML.LIST_MODIFIER);
323 }
324
325 /**
326 * creates and configures all the services - extra_info is some more xml
327 * that is passed to teh service - eg used for coll config files for
328 * Collection
329 */
330 protected boolean configureServiceRackList(Element service_rack_list, Element extra_info)
331 {
332
333 // create all the services
334 NodeList nodes = service_rack_list.getElementsByTagName(GSXML.SERVICE_CLASS_ELEM);
335 if (nodes.getLength() == 0)
336 {
337 logger.error("ServiceCluster configuration error: cluster " + this.cluster_name + " has no service modules!");
338 return false;
339 }
340
341 for (int i = 0; i < nodes.getLength(); i++)
342 {
343
344 // the xml request to send to the serviceRack to query what
345 // services it provides
346 Element message = this.doc.createElement(GSXML.MESSAGE_ELEM);
347 Element request = GSXML.createBasicRequest(this.doc, GSXML.REQUEST_TYPE_DESCRIBE, "", new UserContext());
348 message.appendChild(request);
349
350 Element n = (Element) nodes.item(i);
351 String servicetype = n.getAttribute(GSXML.NAME_ATT);
352
353 ServiceRack s = null;
354
355 try
356 {
357 // try for a default service in standard package
358 s = (ServiceRack) Class.forName("org.greenstone.gsdl3.service." + servicetype).newInstance();
359
360 }
361 catch (Exception e)
362 {
363 }
364 if (s == null)
365 {
366 try
367 {
368 // name as is, in case package is already specified
369 s = (ServiceRack) Class.forName(servicetype).newInstance();
370 }
371 catch (Exception e)
372 {
373 }
374 }
375
376 if (s == null)
377 {
378 logger.error("Couldn't get an instance of class " + servicetype + ", or org.greenstone.gsdl3.service." + servicetype);
379 continue;
380 }
381
382 s.setSiteHome(this.site_home);
383 s.setSiteAddress(this.site_http_address);
384 s.setClusterName(this.cluster_name);
385 s.setMessageRouter(this.router);
386 // pass the xml node to the service for configuration
387 if (s.configure(n, extra_info))
388 {
389
390 // find out the supported service types for this service module
391 Node types = s.process(message);
392 NodeList typenodes = ((Element) types).getElementsByTagName(GSXML.SERVICE_ELEM);
393
394 for (int j = 0; j < typenodes.getLength(); j++)
395 {
396 String service = ((Element) typenodes.item(j)).getAttribute(GSXML.NAME_ATT);
397 if (service_map.get(service) != null)
398 {
399 char extra = '0';
400 String new_service = service + extra;
401
402 while (service_map.get(new_service) != null)
403 {
404 extra++;
405 new_service = service + extra;
406 }
407 this.service_name_map.put(new_service, service);
408 service = new_service;
409 ((Element) typenodes.item(j)).setAttribute(GSXML.NAME_ATT, service);
410 }
411 this.service_map.put(service, s);
412 // also add info to the ServiceInfo XML element
413 this.service_list.appendChild(this.doc.importNode(typenodes.item(j), true));
414 }
415 }
416 }
417
418 return true;
419
420 }
421
422 /**
423 * Process an XML document - uses Strings just calls process(Node).
424 *
425 * @param in
426 * the Document to process - a string
427 * @return the resultant document as a string - contains any error messages
428 * @see String
429 */
430 public String process(String in)
431 {
432
433 Document doc = this.converter.getDOM(in);
434
435 Node res = process(doc);
436 return this.converter.getString(res);
437
438 }
439
440 /**
441 * process XML as Node
442 *
443 */
444 public Node process(Node message_node)
445 {
446
447 Element message = this.converter.nodeToElement(message_node);
448
449 NodeList requests = message.getElementsByTagName(GSXML.REQUEST_ELEM);
450 Document mess_doc = message.getOwnerDocument();
451 Element mainResult = this.doc.createElement(GSXML.MESSAGE_ELEM);
452 if (requests.getLength() == 0)
453 {
454 logger.error("no requests for cluster:" + this.cluster_name);
455 // no requests
456 return mainResult; // for now
457 }
458 for (int i = 0; i < requests.getLength(); i++)
459 {
460 Element request = (Element) requests.item(i);
461 String to = request.getAttribute(GSXML.TO_ATT);
462
463 // the cluster name should be first, check, then remove
464 String clustername = GSPath.getFirstLink(to);
465 if (!clustername.equals(this.cluster_name))
466 {
467 logger.error("cluster name wrong! was " + clustername + " should have been " + this.cluster_name);
468 continue; // ignore this request
469 }
470 to = GSPath.removeFirstLink(to);
471 request.setAttribute(GSXML.TO_ATT, to);
472
473 if (to.equals(""))
474 { // this command is for me
475 Element response = processMessage(request);
476 mainResult.appendChild(response);
477
478 }
479 else
480 { // the request is for one of my services
481 String service = GSPath.getFirstLink(to);
482
483 if (!this.service_map.containsKey(service))
484 {
485 logger.error("non-existant service, " + service + ", specified!");
486 continue;
487 }
488 String real_service = service;
489 if (this.service_name_map.containsKey(service))
490 {
491 real_service = this.service_name_map.get(service);
492 // need to change the to att in the request - give the real service name
493 to = request.getAttribute(GSXML.TO_ATT);
494 String old_to = to;
495 to = GSPath.replaceFirstLink(to, real_service);
496 request.setAttribute(GSXML.TO_ATT, to);
497 }
498 // have to pass the request to the service
499 Element single_message = mess_doc.createElement(GSXML.MESSAGE_ELEM);
500 single_message.appendChild(request);
501 Node response_message = this.service_map.get(service).process(single_message);
502 if (response_message != null)
503 {
504 Element response = (Element) GSXML.getChildByTagName(response_message, GSXML.RESPONSE_ELEM);
505 String from = response.getAttribute(GSXML.FROM_ATT);
506 if (!real_service.equals(service))
507 {
508 // replace the real service name with the pseudo service name
509 from = GSPath.replaceFirstLink(from, service);
510 // also need to do it in the service itself
511 // shoudl this be done here??
512 Element service_elem = (Element) GSXML.getChildByTagName(response, GSXML.SERVICE_ELEM);
513 if (service_elem != null)
514 {
515 service_elem.setAttribute(GSXML.NAME_ATT, service);
516 }
517 }
518 from = GSPath.prependLink(from, this.cluster_name);
519 response.setAttribute(GSXML.FROM_ATT, from);
520 mainResult.appendChild(this.doc.importNode(response, true));
521 }
522
523 } // else
524
525 } // for each request
526 return mainResult;
527 }
528
529 /**
530 * handles requests made to the ServiceCluster itself
531 *
532 * @param req
533 * - the request Element- <request>
534 * @return the result Element - should be <response>
535 */
536 protected Element processMessage(Element request)
537 {
538
539 Element response = this.doc.createElement(GSXML.RESPONSE_ELEM);
540 response.setAttribute(GSXML.FROM_ATT, this.cluster_name);
541 String type = request.getAttribute(GSXML.TYPE_ATT);
542 String lang = request.getAttribute(GSXML.LANG_ATT);
543 response.setAttribute(GSXML.TYPE_ATT, type);
544
545 if (type.equals(GSXML.REQUEST_TYPE_DESCRIBE))
546 {
547 // create the collection element
548 Element description = (Element) this.description.cloneNode(false);
549 // set collection type : mg or mgpp
550 description.setAttribute(GSXML.TYPE_ATT, col_type);
551 description.setAttribute(GSXML.DB_TYPE_ATT, db_type);
552
553 response.appendChild(description);
554 // check the param list
555 Element param_list = (Element) GSXML.getChildByTagName(request, GSXML.PARAM_ELEM + GSXML.LIST_MODIFIER);
556 if (param_list == null)
557 {
558 addAllDisplayInfo(description, lang);
559 description.appendChild(this.service_list);
560 description.appendChild(this.metadata_list);
561 description.appendChild(this.plugin_item_list);
562 return response;
563 }
564
565 // go through the param list and see what components are wanted
566 NodeList params = param_list.getElementsByTagName(GSXML.PARAM_ELEM);
567 for (int i = 0; i < params.getLength(); i++)
568 {
569
570 Element param = (Element) params.item(i);
571 // Identify the structure information desired
572 if (param.getAttribute(GSXML.NAME_ATT).equals(GSXML.SUBSET_PARAM))
573 {
574 String info = param.getAttribute(GSXML.VALUE_ATT);
575 if (info.equals(GSXML.SERVICE_ELEM + GSXML.LIST_MODIFIER))
576 {
577 description.appendChild(this.service_list);
578 }
579 else if (info.equals(GSXML.METADATA_ELEM + GSXML.LIST_MODIFIER))
580 {
581 description.appendChild(metadata_list);
582 }
583 else if (info.equals(GSXML.DISPLAY_TEXT_ELEM + GSXML.LIST_MODIFIER))
584 {
585 addAllDisplayInfo(description, lang);
586 }
587 else if (info.equals(GSXML.PLUGIN_ELEM + GSXML.LIST_MODIFIER))
588 {
589 description.appendChild(plugin_item_list);
590 }
591 }
592 }
593 return response;
594 }
595 /*
596 * if (type.equals(GSXML.REQUEST_TYPE_FORMAT_STRING)) {
597 * logger.error("Received format string request"); String service =
598 * request.getAttribute("service"); logger.error("Service is " +
599 * service); String classifier = null;
600 * if(service.equals("ClassifierBrowse")) { classifier =
601 * request.getAttribute("classifier"); logger.error("Classifier is " +
602 * classifier); } Element format_element = (Element)
603 * GSXML.getChildByTagName(request, GSXML.FORMAT_STRING_ELEM); String
604 * format_string = GSXML.getNodeText(format_element);
605 * logger.error("Format string: " + format_string);
606 * logger.error("Config file location = " +
607 * GSFile.collectionConfigFile(this.site_home, this.cluster_name));
608 *
609 * // check for version file
610 *
611 * String directory = new
612 * File(GSFile.collectionConfigFile(this.site_home,
613 * this.cluster_name)).getParent() + File.pathSeparator;
614 * logger.error("Directory is " + directory);
615 *
616 * String version_filename = "";
617 *
618 * if(service.equals("ClassifierBrowse")) version_filename = directory +
619 * "browse_"+classifier+"_format_statement_version.txt"; else
620 * version_filename = directory + "query_format_statement_version.txt";
621 *
622 * File version_file = new File(version_filename);
623 * logger.error("Version filename is " + version_filename);
624 *
625 * String version_number = "1"; BufferedWriter writer; // = new
626 * BufferedWriter(new FileWriter(version_filename)); //RandomAccessFile
627 * version_file_random_access;
628 *
629 * try{
630 *
631 * if(version_file.exists()) { // Read version BufferedReader reader =
632 * new BufferedReader(new FileReader(version_filename));
633 * //version_file_random_access = new RandomAccessFile(version_file,
634 * "r"); //logger.error(" //version_number =
635 * version_file_random_access.readInt(); version_number =
636 * reader.readLine(); int aInt = Integer.parseInt(version_number) + 1;
637 * version_number = Integer.toString(aInt); reader.close();
638 * //version_file_random_access.close(); } else{ // Create
639 * version_file.createNewFile(); // write 1 to file writer = new
640 * BufferedWriter(new FileWriter(version_filename));
641 * //version_file_random_access = new RandomAccessFile(version_file,
642 * "w"); //version_file_random_access.writeInt(version_number);
643 * writer.write(version_number); writer.close();
644 * //version_file_random_access.close(); }
645 *
646 * // Write version file String format_statement_filename = "";
647 *
648 * if(service.equals("ClassifierBrowse")) format_statement_filename =
649 * directory + "browse_"+classifier+"_format_statement_v" +
650 * version_number + ".txt"; else format_statement_filename = directory +
651 * "query_format_statement_v" + version_number + ".txt";
652 *
653 * logger.error("Format statement filename is " +
654 * format_statement_filename);
655 *
656 * writer = new BufferedWriter(new
657 * FileWriter(format_statement_filename)); writer.write(format_string);
658 * writer.close();
659 *
660 * // Update version number //version_file_random_access = new
661 * RandomAccessFile(version_file, "w");
662 * //version_file_random_access.writeInt(version_number);
663 * //version_file_random_access.close();
664 *
665 * writer = new BufferedWriter(new FileWriter(version_filename));
666 * //version_file_random_access = new RandomAccessFile(version_file,
667 * "w"); //version_file_random_access.writeInt(version_number);
668 * writer.write(version_number); writer.close();
669 *
670 *
671 *
672 * } catch (IOException e) { logger.error("IO Exception "+e);
673 * //System.exit(1); }
674 *
675 *
676 * }
677 */
678 if (type.equals(GSXML.REQUEST_TYPE_SYSTEM))
679 {
680 response = processSystemRequest(request);
681 }
682 else
683 { // unknown type
684 logger.error("cant handle request of type " + type);
685
686 }
687 return response;
688 }
689
690 protected Element processSystemRequest(Element request)
691 {
692
693 Element response = this.doc.createElement(GSXML.RESPONSE_ELEM);
694 response.setAttribute(GSXML.FROM_ATT, this.cluster_name);
695 response.setAttribute(GSXML.TYPE_ATT, GSXML.REQUEST_TYPE_SYSTEM);
696
697 // a list of system requests - should put any error messages
698 // or success messages into response
699 NodeList commands = request.getElementsByTagName(GSXML.SYSTEM_ELEM);
700 String message = null;
701 for (int i = 0; i < commands.getLength(); i++)
702 {
703 // all the commands should be Elements
704 Element elem = (Element) commands.item(i);
705 String action = elem.getAttribute(GSXML.TYPE_ATT);
706 if (action.equals(GSXML.SYSTEM_TYPE_CONFIGURE))
707 {
708 String subset = elem.getAttribute(GSXML.SYSTEM_SUBSET_ATT);
709 if (subset.equals(""))
710 {
711 // need to reconfigure the service cluster
712
713 if (this.configure())
714 {
715 Element s = GSXML.createTextElement(this.doc, GSXML.STATUS_ELEM, this.cluster_name + " reconfigured");
716 response.appendChild(s);
717
718 }
719 else
720 {
721 Element s = GSXML.createTextElement(this.doc, GSXML.STATUS_ELEM, this.cluster_name + " could not be reconfigured");
722 response.appendChild(s);
723 }
724 }
725 else if (this.configureSubset(subset))
726 {
727 Element s = GSXML.createTextElement(this.doc, GSXML.STATUS_ELEM, this.cluster_name + " " + subset + " reconfigured");
728 response.appendChild(s);
729 }
730 else
731 {
732 Element s = GSXML.createTextElement(this.doc, GSXML.STATUS_ELEM, this.cluster_name + " " + subset + " could not be reconfigured");
733 response.appendChild(s);
734 }
735 continue;
736 } // configure action
737
738 String module_name = elem.getAttribute(GSXML.SYSTEM_MODULE_NAME_ATT);
739 String module_type = elem.getAttribute(GSXML.SYSTEM_MODULE_TYPE_ATT);
740 if (action.equals(GSXML.SYSTEM_TYPE_ACTIVATE))
741 {
742 Element s = GSXML.createTextElement(this.doc, GSXML.STATUS_ELEM, "activate action not yet implemented - does it even make sense in this context??");
743 response.appendChild(s);
744 }
745 else if (action.equals(GSXML.SYSTEM_TYPE_DEACTIVATE))
746 {
747 if (module_type.equals(GSXML.SERVICE_ELEM))
748 {
749 // deactivate the service
750 // remove from service_map
751 this.service_map.remove(module_name);
752 Element service_elem = GSXML.getNamedElement(this.service_list, GSXML.SERVICE_ELEM, GSXML.NAME_ATT, module_name);
753 service_list.removeChild(service_elem);
754 message = module_type + ": " + module_name + " deactivated";
755 }
756 else
757 {
758 message = "can't deactivate " + module_type + " type modules!";
759 }
760 Element s = GSXML.createTextElement(this.doc, GSXML.STATUS_ELEM, message);
761 response.appendChild(s);
762 }
763 else
764 {
765 logger.error("cant process system request, action " + action);
766 continue;
767 }
768 } // for each command
769 return response;
770 }
771
772 /**
773 * do a configure on only part of the collection
774 */
775 protected boolean configureSubset(String subset)
776 {
777
778 File configFile = new File(GSFile.siteConfigFile(this.site_home));
779 if (!configFile.exists())
780 {
781 logger.error("site config file: " + configFile.getPath() + " not found!");
782 // wont be able to do any of the requests
783 return false;
784
785 }
786
787 Document site_config_doc = this.converter.getDOM(configFile);
788 if (site_config_doc == null)
789 {
790 logger.error("could not read in site config file: " + configFile.getPath());
791 return false;
792 }
793
794 Element site_config_elem = site_config_doc.getDocumentElement();
795 Element cluster_config_elem = GSXML.getNamedElement((Element) GSXML.getChildByTagName(site_config_elem, GSXML.CLUSTER_ELEM + GSXML.LIST_MODIFIER), GSXML.CLUSTER_ELEM, GSXML.NAME_ATT, this.cluster_name);
796 if (cluster_config_elem == null)
797 {
798 logger.error("site config file: " + configFile.getPath() + " has no element for cluster " + this.cluster_name);
799 // wont be able to do any of teh requests
800 return false;
801
802 }
803 if (subset.equals(GSXML.SERVICE_ELEM + GSXML.LIST_MODIFIER))
804 {
805 Element service_rack_list = (Element) GSXML.getChildByTagName(cluster_config_elem, GSXML.SERVICE_CLASS_ELEM + GSXML.LIST_MODIFIER);
806 clearServices();
807 return configureServiceRackList(service_rack_list, null);
808 }
809 else if (subset.equals(GSXML.METADATA_ELEM + GSXML.LIST_MODIFIER))
810 {
811 this.metadata_list = this.doc.createElement(GSXML.METADATA_ELEM + GSXML.LIST_MODIFIER);
812 Element metadata_list = (Element) GSXML.getChildByTagName(cluster_config_elem, GSXML.METADATA_ELEM + GSXML.LIST_MODIFIER);
813 return addMetadata(metadata_list);
814 }
815 else if (subset.equals(GSXML.PLUGIN_ELEM + GSXML.LIST_MODIFIER))
816 {
817 this.plugin_item_list = this.doc.createElement(GSXML.PLUGIN_ELEM + GSXML.LIST_MODIFIER);
818 Element import_list = (Element) GSXML.getChildByTagName(cluster_config_elem, GSXML.IMPORT_ELEM);
819 if (import_list != null)
820 {
821 Element plugin_item_list = (Element) GSXML.getChildByTagName(cluster_config_elem, GSXML.PLUGIN_ELEM + GSXML.LIST_MODIFIER);
822 return addPlugins(plugin_item_list);
823 }
824 else
825 return false;
826 }
827 else
828 {
829 logger.error("cannot process system request, configure " + subset);
830 return false;
831 }
832
833 }
834
835 protected boolean addAllDisplayInfo(Element description, String lang)
836 {
837
838 NodeList items = this.display_item_list.getChildNodes();
839 for (int i = 0; i < items.getLength(); i++)
840 { // for each key
841 Element m = (Element) items.item(i);
842 // find the child with the correct language
843 Element new_m = GSXML.getNamedElement(m, GSXML.DISPLAY_TEXT_ELEM, GSXML.LANG_ATT, lang);
844 if (new_m == null && lang != DEFAULT_LANG)
845 {
846 // use the default lang
847 new_m = GSXML.getNamedElement(m, GSXML.DISPLAY_TEXT_ELEM, GSXML.LANG_ATT, DEFAULT_LANG);
848 }
849 if (new_m == null)
850 {
851 // just get the first one
852 new_m = (Element) GSXML.getChildByTagName(m, GSXML.DISPLAY_TEXT_ELEM);
853 }
854 description.appendChild(new_m.cloneNode(true));
855 }
856 return true;
857
858 }
859
860 protected Element getDisplayTextElement(String key, String lang)
861 {
862
863 Element this_item = GSXML.getNamedElement(this.display_item_list, GSXML.DISPLAY_TEXT_ELEM, GSXML.NAME_ATT, key);
864 if (this_item == null)
865 {
866 return null;
867 }
868
869 Element this_lang = GSXML.getNamedElement(this_item, GSXML.DISPLAY_TEXT_ELEM, GSXML.LANG_ATT, lang);
870 if (this_lang == null && lang != DEFAULT_LANG)
871 {
872 // try the default
873 this_lang = GSXML.getNamedElement(this_item, GSXML.DISPLAY_TEXT_ELEM, GSXML.LANG_ATT, DEFAULT_LANG);
874 }
875 if (this_lang == null)
876 {
877 // just return the first one
878 return GSXML.getFirstElementChild(this_item);//(Element)this_item.getFirstChild().cloneNode(true);
879 }
880 return (Element) this_lang.cloneNode(true);
881
882 }
883
884 public HashMap<String, ServiceRack> getServiceMap()
885 {
886 return service_map;
887 }
888}
Note: See TracBrowser for help on using the repository browser.