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

Last change on this file since 31061 was 31061, checked in by ak19, 7 years ago

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