source: trunk/gsdl3/src/java/org/greenstone/gsdl3/service/GS2Construct.java@ 3946

Last change on this file since 3946 was 3946, checked in by kjdon, 21 years ago

tidied up System.out.prints
  • Property svn:keywords set to Author Date Id Revision
File size: 25.2 KB
Line 
1/*
2 * GS2Construct.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 */
19package org.greenstone.gsdl3.service;
20
21import org.greenstone.gsdl3.util.*;
22import org.greenstone.gsdl3.build.*;
23
24import org.w3c.dom.Document;
25import org.w3c.dom.Node;
26import org.w3c.dom.Text;
27import org.w3c.dom.Element;
28import org.w3c.dom.NodeList;
29
30import java.util.Collections;
31import java.util.HashMap;
32import java.util.Map;
33import java.util.List;
34import java.util.ArrayList;
35import java.io.File;
36import java.util.Locale;
37
38/**
39 * A Services class for building collections
40 * provides a wrapper around the old perl scripts
41 *
42 * @author <a href="mailto:[email protected]">Katherine Don</a>
43 * @version $Revision: 3946 $
44 */
45public class GS2Construct
46 extends ServiceRack {
47
48 // services offered
49 private static final String NEW_SERVICE = "NewCollection";
50 private static final String ADD_DOC_SERVICE = "AddDocument";
51 private static final String IMPORT_SERVICE = "ImportCollection";
52 private static final String BUILD_SERVICE = "BuildCollection";
53 private static final String ACTIVATE_SERVICE = "ActivateCollection";
54 private static final String DELETE_SERVICE = "DeleteCollection";
55 private static final String RELOAD_SERVICE = "ReloadCollection";
56
57 // params used
58 private static final String COL_PARAM = "collection";
59 private static final String NEW_COL_TITLE_PARAM = "collTitle";
60 private static final String NEW_COL_ABOUT_PARAM = "collAbout";
61 private static final String CREATOR_PARAM = "creator";
62 private static final String NEW_FILE_PARAM = "newfile";
63 private static final String HANDLE_PARAM = "id";
64 private static final String BUILDTYPE_PARAM = "buildType";
65 private static final String BUILDTYPE_MG = "mg";
66 private static final String BUILDTYPE_MGPP = "mgpp";
67
68 // the list of the collections - store between some method calls
69 private String[] collection_list_ = null;
70
71 // set of listeners for any construction commands
72 protected Map listeners_ = null;
73
74 public GS2Construct() {
75 listeners_ = Collections.synchronizedMap(new HashMap());
76
77 }
78
79 /** returns the service list for the subclass */
80 protected Element getServiceList(String lang) {
81 // for now, it is static and there is no lang stuff
82 return short_service_info_;
83 }
84
85 /** returns a specific service description */
86 protected Element getServiceDescription(String service, String lang) {
87 Element descript = (Element)((Element)service_info_map_.get(service)).cloneNode(true);
88 // need to add in collection param list
89 if (!service.equals(NEW_SERVICE)) {//new doesn't need a collection list
90 Element param_list = (Element) GSXML.getChildByTagName(descript, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
91 Element old_param = GSXML.getNamedElement(param_list, GSXML.PARAM_ELEM, GSXML.NAME_ATT, COL_PARAM);
92 collection_list_ = getCollectionList();
93 Element param = GSXML.createParameter(doc_, COL_PARAM, GSXML.PARAM_TYPE_ENUM_SINGLE, null, collection_list_);
94 // put at front of the list
95 param_list.replaceChild(param, old_param);
96 }
97 // for now, create it on the fly - look at caching it later
98 Element display = createServiceDisplay(service, lang);
99 addServiceDisplay(descript, display);
100 return descript;
101
102 }
103
104 /** creates a display element containing all the text strings needed to display the service page, in the language specified */
105 protected Element createServiceDisplay(String service, String lang) {
106 Element display = doc_.createElement(GSXML.DISPLAY_ELEM);
107 display.appendChild(GSXML.createTextElement(doc_, GSXML.DISPLAY_NAME_ELEM, getTextString(service+".name", lang)));
108 display.appendChild(GSXML.createTextElement(doc_, GSXML.DISPLAY_SUBMIT_ELEM, getTextString(service+".submit", lang)));
109
110 Element param;
111 if (service.equals(NEW_SERVICE)) {
112 // have the coll title, about, buildtype and creator params
113 param = GSXML.createParameterDisplay(doc_, NEW_COL_TITLE_PARAM, getTextString("param."+NEW_COL_TITLE_PARAM, lang), null, null);
114 display.appendChild(param);
115 param = GSXML.createParameterDisplay(doc_, CREATOR_PARAM, getTextString("param."+CREATOR_PARAM, lang), null, null);
116 display.appendChild(param);
117 param = GSXML.createParameterDisplay(doc_, NEW_COL_ABOUT_PARAM, getTextString("param."+NEW_COL_ABOUT_PARAM, lang), null, null);
118 display.appendChild(param);
119
120 String[] types = {BUILDTYPE_MGPP, BUILDTYPE_MG};
121 String[] type_texts = {getTextString("param."+BUILDTYPE_PARAM+"."+BUILDTYPE_MGPP, lang), getTextString("param."+BUILDTYPE_PARAM+"."+BUILDTYPE_MG, lang)};
122 param = GSXML.createParameterDisplay(doc_, BUILDTYPE_PARAM, getTextString("param."+BUILDTYPE_PARAM, lang), types, type_texts);
123 display.appendChild(param);
124 } else {
125 // have just the coll param
126 //use the collection list already created - this method is only called directly after getServiceDescription()
127 param = GSXML.createParameterDisplay(doc_, COL_PARAM, getTextString("param."+COL_PARAM, lang), collection_list_, collection_list_);
128 display.appendChild(param);
129 if (service.equals(ADD_DOC_SERVICE)) {
130 // also have the file param
131 param = GSXML.createParameterDisplay(doc_, NEW_FILE_PARAM, getTextString("param."+NEW_FILE_PARAM, lang), null, null);
132 display.appendChild(param);
133 }
134 }
135
136 return display;
137
138 }
139
140 // each service must have a method "process<New service name>"
141
142 protected Element processNewCollection(Element request) {
143 return runCommand(request, CollectionConstructor.NEW);
144 }
145
146 /** TODO:implement this */
147 protected Element processAddDocument(Element request) {
148 // decode the file name, add it to the import directory
149 String name = GSPath.getFirstLink(request.getAttribute(GSXML.TO_ATT));
150 Element response = doc_.createElement(GSXML.RESPONSE_ELEM);
151 response.setAttribute(GSXML.FROM_ATT, name);
152 Element status = doc_.createElement(GSXML.STATUS_ELEM);
153 response.appendChild(status);
154 //String lang = request.getAttribute(GSXML.LANG_ATT);
155 //String request_type = request.getAttribute(GSXML.TYPE_ATT);
156 Text t = doc_.createTextNode("AddDocument: not implemented yet");
157 status.appendChild(t);
158 status.setAttribute(GSXML.STATUS_ERROR_CODE_ATT, Integer.toString(GSStatus.ERROR));
159 return response;
160 }
161 protected Element processImportCollection(Element request) {
162 return runCommand(request, CollectionConstructor.IMPORT);
163 }
164
165 protected Element processBuildCollection(Element request) {
166 return runCommand(request, CollectionConstructor.BUILD);
167 }
168 protected Element processActivateCollection(Element request) {
169 Element response = runCommand(request, CollectionConstructor.ACTIVATE);
170 // this activates the collection on disk. but now we need to tell
171 // the MR about it. but we have to wait until the process is finished.
172 Element status = (Element)GSXML.getChildByTagName(response, GSXML.STATUS_ELEM);
173 Element param_list = (Element)GSXML.getChildByTagName(request, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
174 HashMap params = GSXML.extractParams(param_list, false);
175 String coll_name = (String) params.get(COL_PARAM);
176 String lang = request.getAttribute(GSXML.LANG_ATT);
177 // check for finished
178 int status_code = Integer.parseInt(status.getAttribute(GSXML.STATUS_ERROR_CODE_ATT));
179 if (GSStatus.isCompleted(status_code) &&
180 GSStatus.isError(status_code)) {
181 // we shouldn't carry out the next bit, just return the response
182 return response;
183 }
184 String id = status.getAttribute(GSXML.STATUS_PROCESS_ID_ATT);
185 GS2PerlListener listener = (GS2PerlListener)listeners_.get(id);
186 if (listener==null) {
187 System.err.println("somethings gone wrong, couldn't find the listener");
188 status.setAttribute(GSXML.STATUS_ERROR_CODE_ATT, Integer.toString(GSStatus.ERROR));
189 return response;
190 }
191 while (!GSStatus.isCompleted(status_code)) {
192 // wait for the process, and keep checking the status code
193 // there is probably a better way to do this.
194 try {
195 Thread.currentThread().sleep(100);
196 } catch (Exception e) { // ignore
197 }
198 status_code = listener.getStatus();
199 }
200
201 // add the rest of the messages to the status node
202 Text t = doc_.createTextNode("\n"+listener.getUpdate());
203 status.appendChild(t);
204 status.setAttribute(GSXML.STATUS_ERROR_CODE_ATT, Integer.toString(listener.getStatus()));
205 if (GSStatus.isError(status_code)) {
206 return response; // without doing the next bit
207 }
208
209 t = doc_.createTextNode("\n");
210 status.appendChild(t);
211 // once have got here, we assume
212 // the first bit proceeded successfully, now reload the collection
213 configureRequest("reload", coll_name, status, lang); // this will append more messages to the status, and overwrite the error code att
214 return response;
215
216 }
217 protected Element processDeleteCollection(Element request) {
218
219 // the response to send back
220 String name = GSPath.getFirstLink(request.getAttribute(GSXML.TO_ATT));
221 Element response = doc_.createElement(GSXML.RESPONSE_ELEM);
222 response.setAttribute(GSXML.FROM_ATT, name);
223 Element status = doc_.createElement(GSXML.STATUS_ELEM);
224 response.appendChild(status);
225 Text t = null; // the text node for the error/success message
226 String lang = request.getAttribute(GSXML.LANG_ATT);
227 String request_type = request.getAttribute(GSXML.TYPE_ATT);
228
229 Element param_list = (Element)GSXML.getChildByTagName(request, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
230 HashMap params = GSXML.extractParams(param_list, false);
231
232 boolean get_status_only = false;
233 if (request_type.equals(GSXML.REQUEST_TYPE_STATUS)) {
234 get_status_only = true;
235 }
236 if (get_status_only) {
237 // at the moment, delete is synchronous. but it may take ages so should do the command in another thread maybe? in which case we will want to ask for status
238 System.err.println("had a status request for delete - this shouldn't happen!!");
239 //t = doc_.createTextNode("");
240 //status.appendChild(t);
241 status.setAttribute(GSXML.STATUS_ERROR_CODE_ATT, Integer.toString(GSStatus.ERROR));
242 return response;
243 }
244 String coll_name = (String)params.get(COL_PARAM);
245 String[] args={coll_name};
246 File coll_dir = new File(GSFile.collectionBaseDir(site_home_, coll_name));
247 // check that the coll is there in the first place
248 if (!coll_dir.exists()) {
249 t = doc_.createTextNode(getTextString("delete.exists_error", args, lang));
250 status.appendChild(t);
251 status.setAttribute(GSXML.STATUS_ERROR_CODE_ATT, Integer.toString(GSStatus.ERROR));
252 return response;
253 }
254
255 // try to delete the directory
256 if (!GSFile.deleteFile(coll_dir)) {
257 t = doc_.createTextNode(getTextString("delete.delete_error", args, lang));
258 status.setAttribute(GSXML.STATUS_ERROR_CODE_ATT, Integer.toString(GSStatus.ERROR));
259 status.appendChild(t);
260 return response;
261 }
262 configureRequest("delete", coll_name, status, lang);
263 return response;
264 }
265
266 protected Element processReloadCollection(Element request) {
267
268 // the response to send back
269 String name = GSPath.getFirstLink(request.getAttribute(GSXML.TO_ATT));
270 Element response = doc_.createElement(GSXML.RESPONSE_ELEM);
271 response.setAttribute(GSXML.FROM_ATT, name);
272 Element status = doc_.createElement(GSXML.STATUS_ELEM);
273 response.appendChild(status);
274 Text t = null; // the text node for the error/success message
275
276 String lang = request.getAttribute(GSXML.LANG_ATT);
277 String request_type = request.getAttribute(GSXML.TYPE_ATT);
278
279 Element param_list = (Element)GSXML.getChildByTagName(request, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
280 HashMap params = GSXML.extractParams(param_list, false);
281
282 boolean get_status_only = false;
283 if (request_type.equals(GSXML.REQUEST_TYPE_STATUS)) {
284 get_status_only = true;
285 }
286 if (get_status_only) {
287 // reload is synchronous - this makes no sense
288 System.err.println("had a status request for reload - this shouldn't happen!!");
289 //t = doc_.createTextNode("");
290 //status.appendChild(t);
291 status.setAttribute(GSXML.STATUS_ERROR_CODE_ATT, Integer.toString(GSStatus.ERROR));
292 return response;
293 }
294
295 String coll_name = (String)params.get(COL_PARAM);
296 configureRequest("reload", coll_name, status, lang);
297 return response;
298
299 }
300
301 /** send a configure request to the message router
302 * action name should be "delete" or "reload"
303 * response will be put into the status element
304 */
305 protected void configureRequest(String action_name, String coll_name, Element status, String lang) {
306
307 // send the request to the MR
308 Element message = doc_.createElement(GSXML.MESSAGE_ELEM);
309 Element request = doc_.createElement(GSXML.REQUEST_ELEM);
310 request.setAttribute(GSXML.TYPE_ATT, GSXML.REQUEST_TYPE_CONFIGURE);
311 request.setAttribute(GSXML.TO_ATT, "");
312 message.appendChild(request);
313 Element command = doc_.createElement(GSXML.CONFIGURE_ELEM);
314 command.setAttribute(GSXML.TYPE_ATT, GSXML.COLLECTION_ELEM);
315 command.setAttribute(GSXML.NAME_ATT, coll_name);
316 if (action_name.equals("delete")) {
317 command.setAttribute(GSXML.ACTION_ATT, GSXML.CONFIG_ACTION_DEACTIVATE);
318 } else if (action_name.equals("reload")) {
319 command.setAttribute(GSXML.ACTION_ATT, GSXML.CONFIG_ACTION_ACTIVATE);
320 } else {
321 System.err.println("invalid action name passed to configureRequest:"+action_name);
322 return;
323 }
324 request.appendChild(command);
325 Element response = router_.process(message); // at the moment, get no info in response so ignore it
326 Text t;
327 String[] args={coll_name};
328
329 if (response == null) {
330 t = doc_.createTextNode(getTextString(action_name+".configure_error", args , lang));
331 status.setAttribute(GSXML.STATUS_ERROR_CODE_ATT, Integer.toString(GSStatus.ERROR));
332 status.appendChild(t);
333 return;
334 }
335
336 // if we got here, we have succeeded!
337 t = doc_.createTextNode(getTextString(action_name+".success", args, lang));
338 status.setAttribute(GSXML.STATUS_ERROR_CODE_ATT, Integer.toString(GSStatus.SUCCESS));
339 status.appendChild(t);
340 }
341
342
343 /** configure the service module
344 * for now, all services have type=build - need to think about this
345 */
346 public boolean configure(Element info, Element extra_info) {
347 System.out.println("configuring GS2Construct");
348
349 Element e = null;
350 // hard code in the services for now
351
352 // set up short_service_info_ - for now just has name and type
353
354 e = doc_.createElement(GSXML.SERVICE_ELEM);
355 e.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_PROCESS);
356 e.setAttribute(GSXML.NAME_ATT, NEW_SERVICE);
357 short_service_info_.appendChild(e);
358
359 e = doc_.createElement(GSXML.SERVICE_ELEM);
360 e.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_PROCESS);
361 e.setAttribute(GSXML.NAME_ATT, IMPORT_SERVICE);
362 short_service_info_.appendChild(e);
363
364 e = doc_.createElement(GSXML.SERVICE_ELEM);
365 e.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_PROCESS);
366 e.setAttribute(GSXML.NAME_ATT, BUILD_SERVICE);
367 short_service_info_.appendChild(e);
368
369 e = doc_.createElement(GSXML.SERVICE_ELEM);
370 e.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_PROCESS);
371 e.setAttribute(GSXML.NAME_ATT, ACTIVATE_SERVICE);
372 short_service_info_.appendChild(e);
373
374 e = doc_.createElement(GSXML.SERVICE_ELEM);
375 e.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_PROCESS);
376 e.setAttribute(GSXML.NAME_ATT, DELETE_SERVICE);
377 short_service_info_.appendChild(e);
378
379 e = doc_.createElement(GSXML.SERVICE_ELEM);
380 e.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_PROCESS);
381 e.setAttribute(GSXML.NAME_ATT, RELOAD_SERVICE);
382 short_service_info_.appendChild(e);
383
384 e = doc_.createElement(GSXML.SERVICE_ELEM);
385 e.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_PROCESS);
386 e.setAttribute(GSXML.NAME_ATT, ADD_DOC_SERVICE);
387 short_service_info_.appendChild(e);
388
389 // set up service_info_map_
390 // should have full details about each service incl params lists etc.
391
392 Element param_list;
393 Element param;
394
395 e = doc_.createElement(GSXML.SERVICE_ELEM);
396 e.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_PROCESS);
397 e.setAttribute(GSXML.NAME_ATT, NEW_SERVICE);
398 param_list = doc_.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
399 param = GSXML.createParameter(doc_, NEW_COL_TITLE_PARAM, GSXML.PARAM_TYPE_STRING, "", null);
400 param_list.appendChild(param);
401 param = GSXML.createParameter(doc_, CREATOR_PARAM, GSXML.PARAM_TYPE_STRING, "", null);
402 param_list.appendChild(param);
403 param = GSXML.createParameter(doc_, NEW_COL_ABOUT_PARAM, GSXML.PARAM_TYPE_TEXT, "", null);
404 param_list.appendChild(param);
405 String[] types = {BUILDTYPE_MGPP, BUILDTYPE_MG};
406 param = GSXML.createParameter(doc_, BUILDTYPE_PARAM, GSXML.PARAM_TYPE_ENUM_SINGLE, BUILDTYPE_MGPP, types);
407 param_list.appendChild(param);
408
409 e.appendChild(param_list);
410 service_info_map_.put(NEW_SERVICE, e);
411
412 e = doc_.createElement(GSXML.SERVICE_ELEM);
413 e.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_PROCESS);
414 e.setAttribute(GSXML.NAME_ATT, IMPORT_SERVICE);
415 param_list = doc_.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
416 param = GSXML.createParameter(doc_, COL_PARAM, GSXML.PARAM_TYPE_ENUM_SINGLE, "", null);
417 param_list.appendChild(param);
418 e.appendChild(param_list);
419 service_info_map_.put(IMPORT_SERVICE, e);
420
421 e = doc_.createElement(GSXML.SERVICE_ELEM);
422 e.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_PROCESS);
423 e.setAttribute(GSXML.NAME_ATT, BUILD_SERVICE);
424 param_list = doc_.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
425 param = GSXML.createParameter(doc_, COL_PARAM, GSXML.PARAM_TYPE_ENUM_SINGLE, "", null);
426 param_list.appendChild(param);
427 e.appendChild(param_list);
428 service_info_map_.put(BUILD_SERVICE, e);
429
430 e = doc_.createElement(GSXML.SERVICE_ELEM);
431 e.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_PROCESS);
432 e.setAttribute(GSXML.NAME_ATT, ACTIVATE_SERVICE);
433 param_list = doc_.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
434 param = GSXML.createParameter(doc_, COL_PARAM, GSXML.PARAM_TYPE_ENUM_SINGLE, "", null);
435 param_list.appendChild(param);
436 e.appendChild(param_list);
437 service_info_map_.put(ACTIVATE_SERVICE, e);
438
439 e = doc_.createElement(GSXML.SERVICE_ELEM);
440 e.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_PROCESS);
441 e.setAttribute(GSXML.NAME_ATT, DELETE_SERVICE);
442 param_list = doc_.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
443 param = GSXML.createParameter(doc_, COL_PARAM, GSXML.PARAM_TYPE_ENUM_SINGLE, "", null);
444 param_list.appendChild(param);
445 e.appendChild(param_list);
446 service_info_map_.put(DELETE_SERVICE, e);
447
448 e = doc_.createElement(GSXML.SERVICE_ELEM);
449 e.setAttribute(GSXML.TYPE_ATT, GSXML.SERVICE_TYPE_PROCESS);
450 e.setAttribute(GSXML.NAME_ATT, RELOAD_SERVICE);
451 param_list = doc_.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
452 param = GSXML.createParameter(doc_, COL_PARAM, GSXML.PARAM_TYPE_ENUM_SINGLE, "", null);
453 param_list.appendChild(param);
454 e.appendChild(param_list);
455 service_info_map_.put(RELOAD_SERVICE, e);
456
457
458 return true;
459 }
460
461 /** returns a response element */
462 protected Element runCommand(Element request, int type ) {
463
464 // the response to send back
465 String name = GSPath.getFirstLink(request.getAttribute(GSXML.TO_ATT));
466 Element response = doc_.createElement(GSXML.RESPONSE_ELEM);
467 response.setAttribute(GSXML.FROM_ATT, name);
468 Element status = doc_.createElement(GSXML.STATUS_ELEM);
469 response.appendChild(status);
470
471 String lang = request.getAttribute(GSXML.LANG_ATT);
472 String request_type = request.getAttribute(GSXML.TYPE_ATT);
473
474 Element param_list = (Element)GSXML.getChildByTagName(request, GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
475 HashMap params = GSXML.extractParams(param_list, false);
476
477 boolean get_status_only = false;
478 if (request_type.equals(GSXML.REQUEST_TYPE_STATUS)) {
479 get_status_only = true;
480 }
481
482 // just check for status messages if that's all that's required
483 if (get_status_only) {
484 String id = (String)params.get(HANDLE_PARAM);
485 GS2PerlListener listener = (GS2PerlListener)listeners_.get(id);
486 if (listener==null) {
487 Text t = doc_.createTextNode(getTextString("general.process_id_error", lang));
488 status.appendChild(t);
489 status.setAttribute(GSXML.STATUS_ERROR_CODE_ATT, Integer.toString(GSStatus.ERROR));
490 } else {
491 Text t = doc_.createTextNode(listener.getUpdate());
492 status.appendChild(t);
493 status.setAttribute(GSXML.STATUS_ERROR_CODE_ATT, Integer.toString(listener.getStatus()));
494 // check that we actually should be removing the listener here
495 if (listener.isFinished()) { // remove this listener - its job is done
496 listeners_.remove(id); // not working
497 }
498 }
499 return response;
500
501 }
502
503 // do teh actual command
504 String coll_name=null;
505 if (type==CollectionConstructor.NEW) {
506 String coll_title = (String)params.get(NEW_COL_TITLE_PARAM);
507 coll_name = createNewCollName(coll_title);
508 } else {
509 coll_name = (String)params.get(COL_PARAM);
510 }
511 System.err.println("Coll name = "+coll_name);
512 // makes a paramList of the relevant params
513 Element other_params = extractOtherParams(params, type);
514
515 //create the constructor to do the work
516
517 CollectionConstructor constructor = new GS2PerlConstructor("perl_build");
518 if (!constructor.configure()) {
519 Text t = doc_.createTextNode(getTextString("general.configure_constructor_error", lang));
520 status.appendChild(t);
521 status.setAttribute(GSXML.STATUS_ERROR_CODE_ATT, Integer.toString(GSStatus.ERROR));
522 return response;
523 }
524
525 constructor.setSiteHome(site_home_);
526 constructor.setCollectionName(coll_name);
527 constructor.setActionType(type);
528 constructor.setProcessParams(other_params);
529 // the listener
530 GS2PerlListener listener = new GS2PerlListener();
531 constructor.addListener(listener);
532 constructor.start();
533
534 String id = newID();
535 listeners_.put(id, listener);
536
537 status.setAttribute(GSXML.STATUS_PROCESS_ID_ATT, id);
538 status.setAttribute(GSXML.STATUS_ERROR_CODE_ATT, Integer.toString(GSStatus.ACCEPTED));
539 Text t = doc_.createTextNode(getTextString("general.process_start", lang));
540 status.appendChild(t);
541 return response;
542
543 }
544
545
546 //************************
547 // some helper functions
548 //************************
549
550 /** parse the collect directory and return a list of collection names */
551 protected String[] getCollectionList() {
552
553 File collectDir = new File(GSFile.collectDir(site_home_));
554 if (!collectDir.exists()) {
555 System.err.println("couldn't find collect dir: "+collectDir.toString());
556 return null;
557 }
558 System.out.println("GS2Construct: reading thru directory "+collectDir.getPath()+" to find collections.");
559 File[] contents = collectDir.listFiles();
560 int num_colls=0;
561 for (int i=0; i<contents.length;i++) {
562 if(contents[i].isDirectory() && !contents[i].getName().startsWith("CVS")) {
563 num_colls ++;
564 }
565 }
566
567 String[] names= new String[num_colls];
568
569 for (int i=0, j=0; i<contents.length;i++) {
570 if(contents[i].isDirectory()) {
571 String colName = contents[i].getName();
572 if (!colName.startsWith("CVS")) {
573 names[j] = colName;
574 j++;
575 }
576
577 }
578 }
579
580 return names;
581
582 }
583
584 /** ids used for process id */
585 private int current_id = 0;
586 private String newID() {
587 current_id++;
588 return Integer.toString(current_id);
589 }
590
591 /** creates a new short name from the collection title */
592 protected String createNewCollName(String coll_title) {
593
594 String base_name = null;
595 // take the first 6 letters
596 if (coll_title.length()<6) {
597 base_name = coll_title;
598 } else {
599 base_name = coll_title.substring(0,6);
600 }
601 File coll_dir = new File(GSFile.collectionBaseDir(site_home_, base_name));
602 if (!coll_dir.exists()) { // this name is ok - not used yet
603 return base_name;
604 }
605
606 // now we have to make a new name until we get a good one
607 // try name1, name2 name3 etc
608 int i=0;
609 while(coll_dir.exists()) {
610 i++;
611 coll_dir = new File(GSFile.collectionBaseDir(site_home_, base_name+Integer.toString(i)));
612 }
613 return base_name+Integer.toString(i);
614
615 }
616
617 /** takes the params from the request (in the HashMap) and extracts any
618 * that need to be passed to the constructor and puts them into a
619 * paramList element */
620 protected Element extractOtherParams(HashMap params, int type) {
621
622 Element param_list = doc_.createElement(GSXML.PARAM_ELEM+GSXML.LIST_MODIFIER);
623 if (type == CollectionConstructor.NEW) {
624 Element param = doc_.createElement(GSXML.PARAM_ELEM);
625 param.setAttribute(GSXML.NAME_ATT, "creator");
626 param.setAttribute(GSXML.VALUE_ATT, (String)params.get(CREATOR_PARAM));
627
628 param_list.appendChild(param);
629 param = doc_.createElement(GSXML.PARAM_ELEM);
630 param.setAttribute(GSXML.NAME_ATT, "about");
631 param.setAttribute(GSXML.VALUE_ATT, (String)params.get(NEW_COL_ABOUT_PARAM));
632 param_list.appendChild(param);
633 param = doc_.createElement(GSXML.PARAM_ELEM);
634 param.setAttribute(GSXML.NAME_ATT, "title");
635 param.setAttribute(GSXML.VALUE_ATT, (String)params.get(NEW_COL_TITLE_PARAM));
636 param_list.appendChild(param);
637 param = doc_.createElement(GSXML.PARAM_ELEM);
638 param.setAttribute(GSXML.NAME_ATT, "buildtype");
639 param.setAttribute(GSXML.VALUE_ATT, (String)params.get(BUILDTYPE_PARAM));
640 param_list.appendChild(param);
641 return param_list;
642 }
643
644 // other ones dont have params yet
645 return null;
646 }
647
648}
649
650
Note: See TracBrowser for help on using the repository browser.