|
1
10 package org.mmbase.module.tools;
11
12 import java.io.File  ;
13 import java.util.*;
14
15 import javax.servlet.http.HttpSession ;
16
17 import org.mmbase.bridge.*;
18 import org.mmbase.cache.*;
19 import org.mmbase.core.CoreField;
20 import org.mmbase.core.util.Fields;
21 import org.mmbase.datatypes.DataType;
22 import org.mmbase.datatypes.DataTypes;
23 import org.mmbase.module.Module;
24 import org.mmbase.module.ProcessorModule;
25 import org.mmbase.module.builders.Versions;
26 import org.mmbase.module.core.*;
27 import org.mmbase.model.*;
28 import org.mmbase.security.Rank;
29 import org.mmbase.storage.StorageException;
30 import org.mmbase.storage.search.SearchQueryException;
31 import org.mmbase.util.*;
32 import org.mmbase.util.functions.*;
33 import org.mmbase.util.logging.*;
34 import org.mmbase.util.xml.*;
35 import org.xml.sax.InputSource ;
36
37
45 public class MMAdmin extends ProcessorModule {
46 private static final Logger log = Logging.getLoggerInstance(MMAdmin.class);
47
48 private boolean state = false;
50
51
54 private MMBase mmb = null;
55
56
59 private String lastmsg = "";
60
61
64 private boolean kioskmode = false;
65
66 private static final Parameter PARAM_APPLICATION = new Parameter("application", String .class);
67 private static final Parameter PARAM_BUILDER = new Parameter("builder", String .class);
68 private static final Parameter PARAM_MODULE = new Parameter("module", String .class);
69 private static final Parameter PARAM_FIELD = new Parameter("field", String .class);
70 private static final Parameter PARAM_KEY = new Parameter("key", String .class);
71 private static final Parameter PARAM_PATH = new Parameter("path", String .class);
72 private static final Parameter[] PARAMS_BUILDER = new Parameter[] { PARAM_BUILDER, PARAM_PAGEINFO};
73 private static final Parameter[] PARAMS_APPLICATION = new Parameter[] { PARAM_APPLICATION, PARAM_PAGEINFO};
74
75 {
76 addFunction(new GetNodeListFunction("APPLICATIONS", PARAMS_PAGEINFO));
77 addFunction(new GetNodeListFunction("BUILDERS", PARAMS_PAGEINFO));
78 addFunction(new GetNodeListFunction("MODULES", PARAMS_PAGEINFO));
79 addFunction(new GetNodeListFunction("DATABASES", PARAMS_PAGEINFO));
80 addFunction(new GetNodeListFunction("MULTILEVELCACHEENTRIES", PARAMS_PAGEINFO));
81 addFunction(new GetNodeListFunction("NODECACHEENTRIES", PARAMS_PAGEINFO));
82 addFunction(new GetNodeListFunction("FIELDS", PARAMS_BUILDER));
83
84 addFunction(new ReplaceFunction("VERSION", PARAMS_APPLICATION));
85 addFunction(new ReplaceFunction("INSTALLEDVERSION", PARAMS_APPLICATION));
86 addFunction(new ReplaceFunction("DESCRIPTION", PARAMS_APPLICATION));
87
88 addFunction(new ReplaceFunction("BUILDERVERSION", PARAMS_BUILDER));
89 addFunction(new ReplaceFunction("BUILDERCLASSFILE", PARAMS_BUILDER));
90 addFunction(new ReplaceFunction("BUILDERDESCRIPTION", PARAMS_BUILDER));
91
92 addFunction(new ReplaceFunction("GETDESCRIPTION", new Parameter[] {PARAM_BUILDER, PARAM_FIELD, Parameter.LANGUAGE, PARAM_PAGEINFO}));
93 addFunction(new ReplaceFunction("GETGUINAMEVALUE", new Parameter[] {PARAM_BUILDER, PARAM_FIELD, Parameter.LANGUAGE, PARAM_PAGEINFO}));
94 addFunction(new ReplaceFunction("GETBUILDERFIELD", new Parameter[] {PARAM_BUILDER, PARAM_FIELD, PARAM_KEY, PARAM_PAGEINFO}));
95 addFunction(new ReplaceFunction("GETMODULEPROPERTY", new Parameter[] {PARAM_MODULE, PARAM_KEY, PARAM_PAGEINFO}));
96 addFunction(new ReplaceFunction("MODULEDESCRIPTION", new Parameter[] {PARAM_MODULE, PARAM_PAGEINFO}));
97 addFunction(new ReplaceFunction("MODULECLASSFILE", new Parameter[] {PARAM_MODULE, PARAM_PAGEINFO}));
98
99 addFunction(new ReplaceFunction("MULTILEVELCACHEHITS", PARAMS_PAGEINFO));
100 addFunction(new ReplaceFunction("MULTILEVELCACHEMISSES", PARAMS_PAGEINFO));
101 addFunction(new ReplaceFunction("MULTILEVELCACHEREQUESTS", PARAMS_PAGEINFO));
102 addFunction(new ReplaceFunction("MULTILEVELCACHEPERFORMANCE", PARAMS_PAGEINFO));
103 addFunction(new ReplaceFunction("MULTILEVELCACHESTATE", new Parameter[] {new Parameter("state", String .class), PARAM_PAGEINFO}));
104 addFunction(new ReplaceFunction("MULTILEVELCACHESIZE", PARAMS_PAGEINFO));
105
106 addFunction(new ReplaceFunction("NODECACHEHITS", PARAMS_PAGEINFO));
107 addFunction(new ReplaceFunction("NODECACHEMISSES", PARAMS_PAGEINFO));
108 addFunction(new ReplaceFunction("NODECACHEREQUESTS", PARAMS_PAGEINFO));
109 addFunction(new ReplaceFunction("NODECACHEPERFORMANCE", PARAMS_PAGEINFO));
110 addFunction(new ReplaceFunction("NODECACHESIZE", PARAMS_PAGEINFO));
111 addFunction(new ReplaceFunction("TEMPORARYNODECACHESIZE", PARAMS_PAGEINFO));
112 addFunction(new ReplaceFunction("RELATIONCACHEHITS", PARAMS_PAGEINFO));
113 addFunction(new ReplaceFunction("RELATIONCACHEMISSES", PARAMS_PAGEINFO));
114 addFunction(new ReplaceFunction("RELATIONCACHEREQUESTS", PARAMS_PAGEINFO));
115 addFunction(new ReplaceFunction("RELATIONCACHEPERFORMANCE", PARAMS_PAGEINFO));
116
117 addFunction(new ProcessFunction("LOAD", new Parameter[] {PARAM_APPLICATION, PARAM_PAGEINFO, new Parameter("RESULT", String .class, "")}));
118 addFunction(new ProcessFunction("BUILDERSAVE", new Parameter[] {PARAM_BUILDER, PARAM_PATH, PARAM_PAGEINFO, new Parameter("RESULT", String .class, "")}));
119 }
120
121
122
125 public void init() {
126 String dtmp = System.getProperty("mmbase.kiosk");
127 if (dtmp != null && dtmp.equals("yes")) {
128 kioskmode = true;
129 log.info("*** Server started in kiosk mode ***");
130 }
131 mmb = (MMBase)getModule("MMBASEROOT");
132
133
134 new MMAdminProbe(this, mmb);
135 }
136
137
146 public MMObjectBuilder getListBuilder(String command, Map params) {
147 return new VirtualBuilder(mmb);
148 }
149
150
157 public MMObjectBuilder getMMObject(String path) {
158 int pos = path.lastIndexOf(File.separator);
159 if (pos != -1) {
160 path = path.substring(pos + 1);
161 }
162 return mmb.getMMObject(path);
163 }
164
165
169 public Vector getList(PageInfo sp, StringTagger tagger, String value) {
170 String line = Strip.DoubleQuote(value, Strip.BOTH);
171 StringTokenizer tok = new StringTokenizer(line, "-\n\r");
172 if (tok.hasMoreTokens()) {
173 String cmd = tok.nextToken();
174 log.debug("Cmd '" + cmd + "'");
175 if (!checkUserLoggedOn(sp, cmd, false)) {
176 log.warn("Could not find cloud for " + sp + " returning empty list for " + tagger + "/" + value);
177 return new Vector();
178 }
179 if (cmd.equals("APPLICATIONS")) {
180 tagger.setValue("ITEMS", "5");
181 try {
182 return getApplicationsList();
183 } catch (SearchQueryException e) {
184 log.warn(Logging.stackTrace(e));
185 }
186 }
187 if (cmd.equals("BUILDERS")) {
188 tagger.setValue("ITEMS", "4");
189 if ((tok != null) && (tok.hasMoreTokens())) {
190 tok.nextToken();
191 }
192 return getBuildersList();
193 }
194 if (cmd.equals("FIELDS")) {
195 tagger.setValue("ITEMS", "4");
196 return getFields(tok.nextToken());
197 }
198 if (cmd.equals("MODULEPROPERTIES")) {
199 tagger.setValue("ITEMS", "2");
200 return getModuleProperties(tok.nextToken());
201 }
202 if (cmd.equals("ISOGUINAMES")) {
203 tagger.setValue("ITEMS", "2");
204 return getISOGuiNames(tok.nextToken(), tok.nextToken());
205 }
206 if (cmd.equals("ISODESCRIPTIONS")) {
207 tagger.setValue("ITEMS", "2");
208 return getISODescriptions(tok.nextToken(), tok.nextToken());
209 }
210 if (cmd.equals("MODULES")) {
211 tagger.setValue("ITEMS", "4");
212 return getModulesList();
213 }
214 if (cmd.equals("DATABASES")) {
215 tagger.setValue("ITEMS", "4");
216 return getDatabasesList();
217 }
218 if (cmd.equals("MULTILEVELCACHEENTRIES")) {
219 tagger.setValue("ITEMS", "8");
220 return getMultilevelCacheEntries();
221 }
222 if (cmd.equals("NODECACHEENTRIES")) {
223 tagger.setValue("ITEMS", "4");
224 return getNodeCacheEntries();
225 }
226 }
227 return null;
228 }
229
230
233 private boolean checkAdmin(PageInfo sp, String cmd) {
234 return checkUserLoggedOn(sp, cmd, true);
235 }
236
237
240 private boolean checkUserLoggedOn(PageInfo sp, String cmd, boolean adminonly) {
241
242 if (sp.getCloud() != null) {
243 if ((!adminonly) || sp.getCloud().getUser().getRank().getInt() >= Rank.ADMIN.getInt()) {
244 log.debug("Found cloud " + sp.getCloud().getUser());
245 return true;
246 }
247 }
248
251 HttpSession session = sp.req.getSession(false);
252 Enumeration e = session.getAttributeNames();
253 while (e.hasMoreElements()) {
254 String attribute = (String ) e.nextElement();
255 Object o = session.getAttribute(attribute);
256
257 if (o instanceof Cloud) {
258 Cloud cloud = (Cloud) o;
259 Rank curRank = cloud.getUser().getRank();
260 if (curRank.getInt() >= Rank.ADMIN.getInt()) {
261 return true;
263 }
264 }
265 }
266
267 return false;
268 }
269
270
274 public boolean process(PageInfo sp, Hashtable cmds, Hashtable vars) {
275 String cmdline, token;
276 for (Enumeration h = cmds.keys(); h.hasMoreElements();) {
277 cmdline = (String )h.nextElement();
278 if (!checkAdmin(sp, cmdline)) {
279 log.warn("Could not find cloud for " + sp + " returning false for process " + cmds + "/" + vars);
280 return false;
281 }
282 StringTokenizer tok = new StringTokenizer(cmdline, "-\n\r");
283 token = tok.nextToken();
284 if (token.equals("SERVERRESTART")) {
285 lastmsg = "Server restart is not implemented any more";
286 return false;
287 } else if (token.equals("LOAD") && !kioskmode) {
288 ApplicationResult result = new ApplicationResult();
289 String appname = (String )cmds.get(cmdline);
290 if ("".equals(appname)) {
291 log.warn("Found empty app-name in " + cmds + " (used key " + cmdline + ")");
292 }
293 try {
294 if (new ApplicationInstaller(mmb).installApplication(appname, -1, null, result, new HashSet(), false)) {
295 lastmsg = result.getMessage();
296 } else {
297 lastmsg = "Problem installing application : " + appname + ", cause: " + result.getMessage();
298 }
299 } catch (SearchQueryException e) {
300 log.warn(Logging.stackTrace(e));
301 }
302 if (vars != null) {
303 vars.put("RESULT", lastmsg);
304 }
305 } else if (token.equals("SAVE")) {
306 String appname = (String )cmds.get(cmdline);
307 String savepath = (String )vars.get("PATH");
308 String goal = (String )vars.get("GOAL");
309 boolean includeComments = false;
310 if (tok.hasMoreTokens()) {
311 includeComments = "true".equals(tok.nextToken());
312 }
313 writeApplication(appname, savepath, goal, includeComments);
314 } else if (token.equals("BUILDER")) {
315 doBuilderPosts(tok.nextToken(), cmds, vars);
316 } else if (token.equals("MODULE")) {
317 doModulePosts(tok.nextToken(), cmds, vars);
318 } else if (token.equals("MODULESAVE")) {
319 if (kioskmode) {
320 log.warn("MMAdmin> refused to write module, am in kiosk mode");
321 } else {
322 String modulename = (String )cmds.get(cmdline);
323 String savepath = (String )vars.get("PATH");
324 Module mod = (Module)getModule(modulename);
325 if (mod != null) {
326 try {
327 boolean includeComments = false;
328 if (tok.hasMoreTokens()) {
329 includeComments = "true".equals(tok.nextToken());
330 }
331 ModuleWriter moduleOut = new ModuleWriter(mod);
332 moduleOut.setIncludeComments(includeComments);
333 moduleOut.writeToFile(savepath);
334 } catch (Exception e) {
335 log.error(Logging.stackTrace(e));
336 lastmsg = "Writing finished, problems occurred\n\nError encountered=" + e.getMessage() + "\n\n";
337 return false;
338 }
339 lastmsg = "Writing finished, no problems.\n\nA clean copy of " + modulename + ".xml can be found at : " + savepath + "\n\n";
340 } else {
341 lastmsg = "Writing failed, module : " + modulename + ".xml because module is not loaded\n\n";
342 return false;
343 }
344 }
345 } else if (token.equals("BUILDERSAVE")) {
346 if (kioskmode) {
347 log.warn("MMAdmin> refused to write builder, am in kiosk mode");
348 } else {
349 String buildername = (String )cmds.get(cmdline);
350 String savepath = (String )vars.get("path");
351 MMObjectBuilder bul = getMMObject(buildername);
352 if (bul != null) {
353 boolean result = false;
354 try {
355 boolean includeComments = false;
356 if (tok.hasMoreTokens()) {
357 includeComments = "true".equals(tok.nextToken());
358 }
359 BuilderWriter builderOut = new BuilderWriter(bul);
360 builderOut.setIncludeComments(includeComments);
361 builderOut.setExpandBuilder(false);
362 builderOut.writeToFile(savepath);
363 lastmsg =
364 "Writing finished, no problems.\n\nA clean copy of " + buildername + ".xml can be found at : " + savepath + "\n\n";
365 } catch (Exception e) {
366 log.error(Logging.stackTrace(e));
367 lastmsg = "Writing finished, problems occurred\n\n" + "Error encountered=" + e.getMessage() + "\n\n";
368 }
369 if (vars != null) {
370 vars.put("RESULT", lastmsg);
371 }
372 }
373 }
374 }
375
376 }
377 return false;
378 }
379
380 private String escape(String s) {
382 if (s == null) {
383 return "";
384 } else {
385 Encode encoder = new Encode("ESCAPE_XML");
386 String escaped = encoder.encode(s);
387 return escaped.replaceAll("\n", "<br />");
388 }
389 }
390
391
395 public String replace(PageInfo sp, String cmds) {
396 if (!checkUserLoggedOn(sp, cmds, false)) return "";
397 StringTokenizer tok = new StringTokenizer(cmds, "-\n\r");
398 if (tok.hasMoreTokens()) {
399 String cmd = tok.nextToken();
400 if (cmd.equals("VERSION")) {
401 return "" + getVersion(tok.nextToken());
402 } else if (cmd.equals("INSTALLEDVERSION")) {
403 Versions ver = (Versions) mmb.getBuilder("versions");
404 if (ver == null) {
405 log.warn("Versions builder not installed, Can't get to apps");
406 return null;
407 }
408 return "" + ver.getInstalledVersion(tok.nextToken(), "application");
409 } else if (cmd.equals("DESCRIPTION")) {
410 return escape(getDescription(tok.nextToken()));
411 } else if (cmd.equals("LASTMSG")) {
412 return escape(lastmsg);
414 } else if (cmd.equals("BUILDERVERSION")) {
415 return "" + getBuilderVersion(tok.nextToken());
416 } else if (cmd.equals("BUILDERCLASSFILE")) {
417 return "" + getBuilderClass(tok.nextToken());
418 } else if (cmd.equals("BUILDERDESCRIPTION")) {
419 return "" + getBuilderDescription(tok.nextToken());
420 } else if (cmd.equals("GETDESCRIPTION")) {
421 return getDescription(tok.nextToken(), tok.nextToken(), tok.nextToken());
422 } else if (cmd.equals("GETGUINAMEVALUE")) {
423 return getGuiNameValue(tok.nextToken(), tok.nextToken(), tok.nextToken());
424 } else if (cmd.equals("GETBUILDERFIELD")) {
425 return getBuilderField(tok.nextToken(), tok.nextToken(), tok.nextToken());
426 } else if (cmd.equals("GETMODULEPROPERTY")) {
427 return getModuleProperty(tok.nextToken(), tok.nextToken());
428 } else if (cmd.equals("MODULEDESCRIPTION")) {
429 return "" + getModuleDescription(tok.nextToken());
430 } else if (cmd.equals("MODULECLASSFILE")) {
431 return "" + getModuleClass(tok.nextToken());
432 } else if (cmd.equals("MULTILEVELCACHEHITS")) {
433 return ("" + MultilevelCache.getCache().getHits());
434 } else if (cmd.equals("MULTILEVELCACHEMISSES")) {
435 return ("" + MultilevelCache.getCache().getMisses());
436 } else if (cmd.equals("MULTILEVELCACHEREQUESTS")) {
437 return ("" + (MultilevelCache.getCache().getHits() + MultilevelCache.getCache().getMisses()));
438 } else if (cmd.equals("MULTILEVELCACHEPERFORMANCE")) {
439 return ("" + (MultilevelCache.getCache().getRatio() * 100));
440 } else if (cmd.equals("MULTILEVELCACHESTATE")) {
441 if (tok.hasMoreTokens()) {
442 String state = tok.nextToken();
443 if (state.equalsIgnoreCase("On")) {
444 MultilevelCache.getCache().setActive(true);
445 log.info("turned multilevelcache on");
446 } else if (state.equalsIgnoreCase("Off")) {
447 MultilevelCache.getCache().setActive(false);
448 log.info("turned multilevelcache off");
449 }
450 } else {
451 if (MultilevelCache.getCache().isActive()) {
452 return "On";
453 } else {
454 return "Off";
455 }
456 }
457 } else if (cmd.equals("MULTILEVELCACHESIZE")) {
458 return ("" + (MultilevelCache.getCache().maxSize()));
459 } else if (cmd.equals("NODECACHEHITS")) {
460 return ("" + NodeCache.getCache().getHits());
461 } else if (cmd.equals("NODECACHEMISSES")) {
462 return ("" + NodeCache.getCache().getMisses());
463 } else if (cmd.equals("NODECACHEREQUESTS")) {
464 return ("" + (NodeCache.getCache().getHits() + NodeCache.getCache().getMisses()));
465 } else if (cmd.equals("NODECACHEPERFORMANCE")) {
466 return ("" + (NodeCache.getCache().getRatio() * 100));
467 } else if (cmd.equals("NODECACHESIZE")) {
468 return ("" + (NodeCache.getCache().maxSize()));
469 } else if (cmd.equals("TEMPORARYNODECACHESIZE")) {
470 return ("" + (MMObjectBuilder.temporaryNodes.size()));
471 } else if (cmd.equals("RELATIONCACHEHITS")) {
472 return ("" + RelationsCache.getCache().getHits());
473 } else if (cmd.equals("RELATIONCACHEMISSES")) {
474 return ("" + RelationsCache.getCache().getMisses());
475 } else if (cmd.equals("RELATIONCACHEREQUESTS")) {
476 return ("" + (RelationsCache.getCache().getHits() + RelationsCache.getCache().getMisses()));
477 } else if (cmd.equals("RELATIONCACHEPERFORMANCE")) {
478 return
479 ""
480 + (1.0 * RelationsCache.getCache().getHits())
481 / (RelationsCache.getCache().getHits() + RelationsCache.getCache().getMisses() + 0.0000000001)
482 * 100;
483 }
484 }
485 return "No command defined";
486 }
487
488
491 int getVersion(String appname) {
492 ApplicationReader reader = getApplicationReader(appname);
493 if (reader != null) {
494 return reader.getVersion();
495 }
496 return -1;
497 }
498
499 private String getXMLPath(String builderName) {
501 MMObjectBuilder bul = mmb.getBuilder(builderName);
502 if (bul==null) {
503 return "";
504 } else {
505 return bul.getXMLPath();
506 }
507 }
508
509
512 int getBuilderVersion(String builderName) {
513 int version = -1;
514 BuilderReader bul = mmb.getBuilderReader(getXMLPath(builderName) + builderName);
515 if (bul != null) {
516 version = bul.getVersion();
517 }
518 return version;
519 }
520
521
524 String getBuilderClass(String builderName) {
525 String className = "";
526 BuilderReader bul = mmb.getBuilderReader(getXMLPath(builderName) + builderName);
527 if (bul != null) {
528 className = bul.getClassName();
529 }
530 return className;
531 }
532
533
536 String getModuleClass(String modname) {
537 String className = "";
538 ModuleReader mod = getModuleReader(modname);
539 if (mod != null) {
540 className = mod.getClassName();
541 }
542 return className;
543 }
544
545
548 public void setModuleProperty(Hashtable vars) {
549 if (kioskmode) {
550 log.warn("refused module property set, am in kiosk mode");
551 return;
552 }
553 String modname = (String )vars.get("MODULE");
554 String key = (String )vars.get("PROPERTYNAME");
555 String value = (String )vars.get("VALUE");
556 Module mod = (Module)getModule(modname);
557 log.debug("MOD=" + mod);
558 if (mod != null) {
559 mod.setInitParameter(key, value);
560 syncModuleXML(mod, modname);
561 }
562
563 }
564
565
569 String getModuleProperty(String modname, String key) {
570 Module mod = (Module)getModule(modname);
571 if (mod != null) {
572 String value = mod.getInitParameter(key);
573 if (value != null) {
574 return value;
575 }
576 }
577 return "";
578
579 }
580
581
584 String getDescription(String appname) {
585 ApplicationReader reader = getApplicationReader(appname);
586 if (reader != null) {
587 return reader.getDescription();
588 }
589 return "";
590
591 }
592
593
596 String getBuilderDescription(String builderName) {
597 String description = "";
598 BuilderReader bul = mmb.getBuilderReader(getXMLPath(builderName) + builderName);
599 if (bul != null) {
600 Hashtable desc = bul.getDescriptions();
601 String english = (String )desc.get("en");
602 if (english != null) {
603 description = english;
604 }
605 }
606 return description;
607 }
608
609
612 String getModuleDescription(String modulename) {
613 Module mod = (Module)getModule(modulename);
614 if (mod != null) {
615 String value = mod.getModuleInfo();
616 if (value != null)
617 return value;
618 }
619 return "";
620 }
621
622
623
626 public void probeCall() throws SearchQueryException {
627 Versions ver = (Versions)mmb.getMMObject("versions");
628 if (ver == null) {
629 log.warn("Versions builder not installed, Can't auto deploy apps");
630 return;
631 }
632 ApplicationInstaller installer = new ApplicationInstaller(mmb);
633
634 installer.installApplications();
635 state = true;
636 }
637
638
642
643 public boolean getState() {
644 return state;
645 }
646
647
650 private boolean writeApplication(String name, String targetPath, String goal, boolean includeComments) {
651 if (kioskmode) {
652 log.warn("refused to write application, am in kiosk mode");
653 return false;
654 }
655 ApplicationReader reader = getApplicationReader(name);
656 ApplicationWriter writer = new ApplicationWriter(reader, mmb);
657 writer.setIncludeComments(includeComments);
658 java.io.Writer w = new java.io.StringWriter ();
659 Logger logger = new WriterLogger(w);
660 try {
661 writer.writeToPath(targetPath, logger);
662 lastmsg = "Application saved oke\n\n";
663 } catch (Exception e) {
664 lastmsg = "Saving application failed\n\n" + Logging.stackTrace(e) + "\n\n";
665 }
666 lastmsg += "Some statistics on the save : \n\n" + w.toString();
667 return true;
668 }
669
670
676 private ApplicationReader getApplicationReader(String appName) {
677 String resourceName = appName + ".xml";
678 try {
679 ResourceLoader applicationLoader = ResourceLoader.getConfigurationRoot().getChildResourceLoader("applications");
680 InputSource is = applicationLoader.getInputSource(resourceName);
681 if (is == null) {
682 return null;
683 }
684 return new ApplicationReader(is);
685 } catch (Exception e) {
686 log.error("error while reading application from resource " + resourceName + " : " + e.getMessage() , e);
687 return null;
688 }
689 }
690
691
694 Vector getApplicationsList() throws SearchQueryException {
695 Vector results = new Vector(); if (mmb == null) {
697 log.warn("MMBase not yet initialized, Can't get to apps");
698 return results;
699 }
700 Versions ver = (Versions) mmb.getMMObject("versions");
701 if (ver == null) {
702 log.warn("Versions builder not installed, Can't get to apps");
703 return results;
704 }
705
706
707 ResourceLoader applicationLoader = ResourceLoader.getConfigurationRoot().getChildResourceLoader("applications");
708 Iterator i = applicationLoader.getResourcePaths(ResourceLoader.XML_PATTERN, false).iterator();
709 while (i.hasNext()) {
710 String appResource = (String ) i.next();
711 log.debug("application " + appResource);
712 ApplicationReader reader;
713 try {
714 reader = new ApplicationReader(applicationLoader.getInputSource(appResource));
715 } catch (Exception e) {
716 log.error(e);
717 continue;
718 }
719
720 String name = reader.getName();
721 results.add(name);
722 results.add("" + reader.getVersion());
723 int installedversion = ver.getInstalledVersion(name, "application");
724 if (installedversion == -1) {
725 results.add("no");
726 } else {
727 results.add("yes (ver : " + installedversion + ")");
728 }
729 results.add(reader.getMaintainer());
730 boolean autodeploy = reader.hasAutoDeploy();
731 if (autodeploy) {
732 results.add("yes");
733 } else {
734 results.add("no");
735 }
736 }
737 return results;
738 }
739
740
743 Vector getBuildersList() {
744 Versions ver = (Versions)mmb.getMMObject("versions");
745 Vector results = new Vector();
746 ResourceLoader builderLoader = mmb.getBuilderLoader();
747 Iterator builders = builderLoader.getResourcePaths(ResourceLoader.XML_PATTERN, true).iterator();
748 while (builders.hasNext()) {
749 String builderResource = (String ) builders.next();
750 String builderName = ResourceLoader.getName(builderResource);
751 BuilderReader reader = mmb.getBuilderReader(getXMLPath(builderName) + builderName);
752 if (reader == null) {
753 log.error("Did not find reader for " + builderResource);
754 continue;
755 }
756 results.add(builderName);
757 results.add("" + reader.getVersion());
758 int installedversion = -1;
759 if (ver != null) {
760 installedversion = ver.getInstalledVersion(builderName, "builder");
761 }
762 if (installedversion == -1) {
763 results.add("no");
764 } else {
765 results.add("yes");
766 }
767 results.add(reader.getMaintainer());
768 }
769 return results;
770 }
771
772
775 Vector getModuleProperties(String modulename) {
776 Vector results = new Vector();
777 ModuleReader mod = getModuleReader(modulename);
778 if (mod != null) {
779 Map props = mod.getProperties();
780 for (Iterator i = props.keySet().iterator(); i.hasNext();) {
781 String key = (String )i.next();
782 String value = (String )props.get(key);
783 results.add(key);
784 results.add(value);
785 }
786 }
787 return results;
788 }
789
790
793 Vector getFields(String builderName) {
794 Vector results = new Vector();
795 BuilderReader bul = mmb.getBuilderReader(getXMLPath(builderName) + builderName);
796 if (bul != null) {
797 List defs = bul.getFields();
798 for (Iterator h = defs.iterator(); h.hasNext();) {
799 CoreField def = (CoreField) h.next();
800 results.add("" + def.getStoragePosition());
801 results.add("" + def.getName());
802 results.add(Fields.getTypeDescription(def.getType()));
803 int size = def.getMaxLength();
804 if (size == -1) {
805 results.add("fixed");
806 } else {
807 results.add("" + size);
808 }
809 }
810 }
811 return results;
812 }
813
814
817 Vector getModulesList() {
818 Vector results = new Vector();
819 ResourceLoader moduleLoader = getModuleLoader();
820 Set modules = moduleLoader.getResourcePaths(ResourceLoader.XML_PATTERN, false);
822 Iterator i = modules.iterator();
823 while (i.hasNext()) {
824 String path = (String ) i.next();
825 String sname = ResourceLoader.getName(path);
826 ModuleReader reader = getModuleReader(sname);
827 if (reader == null) {
828 log.error("Could not load module with xml '" + path + "'");
829 continue;
830 }
831 results.add(sname);
832 results.add("" + reader.getVersion());
833 String status = reader.getStatus();
834 if (status.equals("active")) {
835 results.add("yes");
836 } else {
837 results.add("no");
838 }
839 results.add(reader.getMaintainer());
840 }
841 return results;
842 }
843
844
847 Vector getDatabasesList() {
848 Versions ver = (Versions)mmb.getMMObject("versions");
849 if (ver == null) {
850 log.warn("Versions builder not installed, Can't get to builders");
851 return null;
852 }
853 Vector results = new Vector();
854
855 String path = MMBaseContext.getConfigPath() + File.separator + "databases" + File.separator;
856 File bdir = new File (path);
858 if (bdir.isDirectory()) {
859 String files[] = bdir.list();
860 if (files == null)
861 return results;
862 for (int i = 0; i < files.length; i++) {
863 String aname = files[i];
864 if (aname.endsWith(".xml")) {
865 String name = aname;
866 String sname = name.substring(0, name.length() - ".xml".length());
867 results.add(sname);
868
869 results.add("0");
870 results.add("yes");
871 results.add("mmbase.org");
872 }
873 }
874 }
875 return results;
876 }
877
878
881 private String getBuilderField(String buildername, String fieldname, String key) {
882 MMObjectBuilder bul = getMMObject(buildername);
883 if (bul != null) {
884 CoreField def = bul.getField(fieldname);
885 if (key.equals("dbkey")) {
886 if (def.isUnique()) {
887 return "true";
888 } else {
889 return "false";
890 }
891 } else if (key.equals("dbnotnull")) {
892 if (def.isRequired()) {
893 return "true";
894 } else {
895 return "false";
896 }
897 } else if (key.equals("dbname")) {
898 return def.getName();
899 } else if (key.equals("dbsize")) {
900 int size = def.getMaxLength();
901 if (size != -1) {
902 return "" + size;
903 } else {
904 return "fixed";
905 }
906 } else if (key.equals("dbstate")) {
907 return Fields.getStateDescription(def.getState());
908 } else if (key.equals("dbmmbasetype")) {
909 return Fields.getTypeDescription(def.getType());
910 } else if (key.equals("editorinput")) {
911 int pos = def.getEditPosition();
912 if (pos == -1) {
913 return "not shown";
914 } else {
915 return "" + pos;
916 }
917 } else if (key.equals("editorsearch")) {
918 int pos = def.getSearchPosition();
919 if (pos == -1) {
920 return "not shown";
921 } else {
922 return "" + pos;
923 }
924 } else if (key.equals("editorlist")) {
925 int pos = def.getListPosition();
926 if (pos == -1) {
927 return "not shown";
928 } else {
929 return "" + pos;
930 }
931 } else if (key.equals("guitype")) {
932 return def.getGUIType();
933 }
934 }
935 return "";
936 }
937
938
941 private Vector getISOGuiNames(String buildername, String fieldname) {
942 Vector results = new Vector();
943 MMObjectBuilder bul = getMMObject(buildername);
944 if (bul != null) {
945 CoreField def = bul.getField(fieldname);
946 Map guinames = def.getLocalizedGUIName().asMap();
947 for (Iterator h = guinames.entrySet().iterator(); h.hasNext();) {
948 Map.Entry me = (Map.Entry) h.next();
949 results.add(((Locale) me.getKey()).getLanguage());
950 results.add(me.getValue());
951 }
952 }
953 return results;
954 }
955
956
959 private Vector getISODescriptions(String buildername, String fieldname) {
960 Vector results = new Vector();
961 MMObjectBuilder bul = getMMObject(buildername);
962 if (bul != null) {
963 CoreField def = bul.getField(fieldname);
964 Map guinames = def.getLocalizedDescription().asMap();
965 for (Iterator h = guinames.entrySet().iterator(); h.hasNext();) {
966 Map.Entry me = (Map.Entry)h.next();
967 results.add(((Locale) me.getKey()).getLanguage());
968 results.add(me.getValue());
969 }
970 }
971 return results;
972 }
973
974
977 private String getGuiNameValue(String buildername, String fieldname, String lang) {
978 MMObjectBuilder bul = getMMObject(buildername);
979 if (bul != null) {
980 CoreField def = bul.getField(fieldname);
981 String value = def.getGUIName(new Locale(lang, ""));
982 if (value != null) {
983 return value;
984 }
985 }
986 return "";
987 }
988
989
992 private String getDescription(String buildername, String fieldname, String lang) {
993 MMObjectBuilder bul = getMMObject(buildername);
994 if (bul != null) {
995 CoreField def = bul.getField(fieldname);
996 String value = def.getDescription(new Locale(lang, ""));
997 if (value != null) {
998 return value;
999 }
1000 }
1001 return "";
1002 }
1003
1004
1007 public void doModulePosts(String command, Hashtable cmds, Hashtable vars) {
1008 if (command.equals("SETPROPERTY")) {
1009 setModuleProperty(vars);
1010 }
1011 }
1012
1013
1016 public void doBuilderPosts(String command, Hashtable cmds, Hashtable vars) {
1017 if (command.equals("SETGUINAME")) {
1018 setBuilderGuiName(vars);
1019 } else if (command.equals("SETDESCRIPTION")) {
1020 setBuilderDescription(vars);
1021 } else if (command.equals("SETGUITYPE")) {
1022 setBuilderGuiType(vars);
1023 } else if (command.equals("SETEDITORINPUT")) {
1024 setBuilderEditorInput(vars);
1025 } else if (command.equals("SETEDITORLIST")) {
1026 setBuilderEditorList(vars);
1027 } else if (command.equals("SETEDITORSEARCH")) {
1028 setBuilderEditorSearch(vars);
1029 } else if (command.equals("SETDBSIZE")) {
1030 setBuilderDBSize(vars);
1031 } else if (command.equals("SETDBKEY")) {
1032 setBuilderDBKey(vars);
1033 } else if (command.equals("SETDBNOTNULL")) {
1034 setBuilderDBNotNull(vars);
1035 } else if (command.equals("SETDBMMBASETYPE")) {
1036 setBuilderDBField(vars);
1037 } else if (command.equals("SETSTATE")) {
1038 setBuilderDBState(vars);
1039 } else if (command.equals("ADDFIELD")) {
1040 addBuilderField(vars);
1041 } else if (command.equals("REMOVEFIELD")) {
1042 removeBuilderField(vars);
1043 }
1044 }
1045
1046
1049 public void setBuilderGuiName(Hashtable vars) {
1050 if (kioskmode) {
1051 log.warn("refused gui name set, am in kiosk mode");
1052 return;
1053 }
1054 String builder = (String )vars.get("BUILDER");
1055 String fieldname = (String )vars.get("FIELDNAME");
1056 String country = (String )vars.get("COUNTRY");
1057 String value = (String )vars.get("VALUE");
1058
1059 MMObjectBuilder bul = getMMObject(builder);
1060 CoreField def = bul.getField(fieldname);
1061 if (def != null) {
1062 def.setGUIName(value, new Locale(country, ""));
1063 }
1064
1065 CloudModel cloudmodel = ModelsManager.getModel("default");
1066 if (cloudmodel != null) {
1067 CloudModelBuilder cloudmodelbuilder = cloudmodel.getModelBuilder(builder);
1068 if (cloudmodelbuilder != null) cloudmodelbuilder.setGuiName(fieldname,country,value);
1069 }
1070 }
1071
1072
1076 public void setBuilderDescription(Hashtable vars) {
1077 if (kioskmode) {
1078 log.warn("refused gui name set, am in kiosk mode");
1079 return;
1080 }
1081 String builder = (String )vars.get("BUILDER");
1082 String fieldname = (String )vars.get("FIELDNAME");
1083 String country = (String )vars.get("COUNTRY");
1084 String value = (String )vars.get("VALUE");
1085
1086 MMObjectBuilder bul = getMMObject(builder);
1087 CoreField def = bul.getField(fieldname);
1088 if (def != null) {
1089 def.setDescription(value, new Locale(country, ""));
1090 }
1091 }
1093
1094
1097 public void setBuilderGuiType(Hashtable vars) {
1098 if (kioskmode) {
1099 log.warn("refused gui type set, am in kiosk mode");
1100 return;
1101 }
1102 String builder = (String )vars.get("BUILDER");
1103 String fieldName = (String )vars.get("FIELDNAME");
1104 String guiType = (String )vars.get("VALUE");
1105
1106 MMObjectBuilder bul = getMMObject(builder);
1107 CoreField def = bul.getField(fieldName);
1108 if (def != null) {
1109 DataType dataType;
1110 int type = def.getType();
1111 if (type == Field.TYPE_LIST) {
1112 dataType = DataTypes.getDataTypeInstance(guiType, def.getListItemType());
1113 } else {
1114 dataType = DataTypes.getDataTypeInstance(guiType, type);
1115 }
1116 def.setDataType(dataType);
1117 def.finish();
1118 }
1119 }
1121
1122
1125 public void setBuilderEditorInput(Hashtable vars) {
1126 if (kioskmode) {
1127 log.warn("refused editor input set, am in kiosk mode");
1128 return;
1129 }
1130 String builder = (String )vars.get("BUILDER");
1131 String fieldname = (String )vars.get("FIELDNAME");
1132 String value = (String )vars.get("VALUE");
1133
1134 MMObjectBuilder bul = getMMObject(builder);
1135 CoreField def = bul.getField(fieldname);
1136 if (def != null) {
1137 try {
1138 int i = Integer.parseInt(value);
1139 def.setEditPosition(i);
1140 } catch (Exception e) {}
1141 }
1142 }
1144
1145
1148 public void setBuilderEditorList(Hashtable vars) {
1149 if (kioskmode) {
1150 log.warn("refused editor list set, am in kiosk mode");
1151 return;
1152 }
1153 String builder = (String )vars.get("BUILDER");
1154 String fieldname = (String )vars.get("FIELDNAME");
1155 String value = (String )vars.get("VALUE");
1156
1157 MMObjectBuilder bul = getMMObject(builder);
1158 CoreField def = bul.getField(fieldname);
1159 if (def != null) {
1160 try {
1161 int i = Integer.parseInt(value);
1162 def.setListPosition(i);
1163 } catch (Exception e) {}
1164 }
1165 }
1167
1168
1171 public void setBuilderEditorSearch(Hashtable vars) {
1172 if (kioskmode) {
1173 log.warn("refused editor pos set, am in kiosk mode");
1174 return;
1175 }
1176 String builder = (String )vars.get("BUILDER");
1177 String fieldname = (String )vars.get("FIELDNAME");
1178 String value = (String )vars.get("VALUE");
1179
1180 MMObjectBuilder bul = getMMObject(builder);
1181 CoreField def = bul.getField(fieldname);
1182 if (def != null) {
1183 try {
1184 int i = Integer.parseInt(value);
1185 def.setSearchPosition(i);
1186 } catch (Exception e) {}
1187 }
1188 }
1190
1191
1194 public void setBuilderDBSize(Hashtable vars) {
1195 if (kioskmode) {
1196 log.warn("Refused set DBSize field, am in kiosk mode");
1197 return;
1198 }
1199 String builder = (String )vars.get("BUILDER");
1200 String fieldname = (String )vars.get("FIELDNAME");
1201 String value = (String )vars.get("VALUE");
1202
1203 MMObjectBuilder bul = getMMObject(builder);
1204 CoreField def = bul.getField(fieldname);
1205 if (def != null) {
1206 int oldSize = def.getMaxLength();
1207 try {
1208 int newSize = Integer.parseInt(value);
1209 if (newSize != oldSize) {
1210 def.rewrite();
1211 try {
1212 def.setMaxLength(newSize);
1213 mmb.getStorageManager().change(def);
1215 CloudModel cloudmodel = ModelsManager.getModel("default");
1216 if (cloudmodel != null) {
1217 CloudModelBuilder cloudmodelbuilder = cloudmodel.getModelBuilder(builder);
1218 if (cloudmodelbuilder != null) cloudmodelbuilder.setBuilderDBSize(fieldname,value);
1219 }
1220 } catch (StorageException se) {
1221 def.setMaxLength(oldSize);
1222 throw se;
1223 } finally {
1224 def.finish();
1225 }
1226 }
1227 } catch (NumberFormatException nfe) {
1228 throw new RuntimeException (nfe);
1229 }
1230 }
1231 }
1232
1233
1236 public void setBuilderDBField(Hashtable vars) {
1237 if (kioskmode) {
1238 log.warn("Refused set setDBField field, am in kiosk mode");
1239 return;
1240 }
1241 String builder = (String )vars.get("BUILDER");
1242 String fieldname = (String )vars.get("FIELDNAME");
1243 String value = (String )vars.get("VALUE");
1244
1245 MMObjectBuilder bul = getMMObject(builder);
1246 CoreField def = bul.getField(fieldname);
1247 if (def != null) {
1248 int oldType = def.getType();
1249 int newType = Fields.getType(value);
1250 if (oldType != newType) {
1251 def.rewrite();
1252 def.setType(newType);
1253 try {
1254 mmb.getStorageManager().change(def);
1256 } catch (StorageException se) {
1258 def.setType(oldType);
1259 throw se;
1260 } finally {
1261 def.finish();
1262 }
1263 }
1264 }
1265 }
1266
1267
1270 public void setBuilderDBState(Hashtable vars) {
1271 if (kioskmode) {
1272 log.warn("Refused set DBState field, am in kiosk mode");
1273 return;
1274 }
1275 log.info("SET DBDSTATE");
1276 String builder = (String )vars.get("BUILDER");
1277 String fieldname = (String )vars.get("FIELDNAME");
1278 String value = (String )vars.get("VALUE");
1279
1280 MMObjectBuilder bul = getMMObject(builder);
1281 CoreField def = bul.getField(fieldname);
1282 if (def != null) {
1283 int oldState = def.getState();
1284 int newState = Fields.getState(value);
1285 if (oldState != newState) {
1286 boolean oldInStorage = def.inStorage();
1287 def.rewrite();
1288 def.setState(newState);
1289 try {
1290 if (def.inStorage() && !oldInStorage) {
1292 mmb.getStorageManager().create(def);
1294 bul.addField(def);
1296 }
1298 } catch (StorageException se) {
1299 def.setState(oldState);
1300 throw se;
1301 } finally {
1302 def.finish();
1303 }
1304 CloudModel cloudmodel = ModelsManager.getModel("default");
1305 if (cloudmodel != null) {
1306 CloudModelBuilder cloudmodelbuilder = cloudmodel.getModelBuilder(builder);
1307 if (cloudmodelbuilder != null) cloudmodelbuilder.setBuilderDBState(fieldname,value);
1308 }
1309 }
1310 }
1311 }
1312
1313
1316 public void setBuilderDBKey(Hashtable vars) {
1317 if (kioskmode) {
1318 log.warn("Refused set dbkey field, am in kiosk mode");
1319 return;
1320 }
1321 log.info("SET DBKEY");
1322 String builder = (String )vars.get("BUILDER");
1323 String fieldname = (String )vars.get("FIELDNAME");
1324 String value = (String )vars.get("VALUE");
1325
1326 MMObjectBuilder bul = getMMObject(builder);
1327 CoreField def = bul.getField(fieldname);
1328 if (def != null) {
1329 def.rewrite();
1330 if (value.equals("true")) {
1331 def.setUnique(true);
1332 } else {
1333 def.setUnique(false);
1334 }
1335 CloudModel cloudmodel = ModelsManager.getModel("default");
1336 if (cloudmodel != null) {
1337 CloudModelBuilder cloudmodelbuilder = cloudmodel.getModelBuilder(builder);
1338 if (cloudmodelbuilder != null) cloudmodelbuilder.setBuilderDBKey(fieldname,value);
1339 }
1340 def.finish();
1341 }
1342 }
1345
1346
1349 public void setBuilderDBNotNull(Hashtable vars) {
1350 if (kioskmode) {
1351 log.warn("Refused set NotNull field, am in kiosk mode");
1352 return;
1353 }
1354 String builder = (String )vars.get("BUILDER");
1355 String fieldname = (String )vars.get("FIELDNAME");
1356 String value = (String )vars.get("VALUE");
1357
1358 MMObjectBuilder bul = getMMObject(builder);
1359 CoreField def = bul.getField(fieldname);
1360 if (def != null) {
1361 boolean oldNotNull = def.isRequired();
1362 boolean newNotNull = value.equals("true");
1363 if (oldNotNull != newNotNull) {
1364 def.rewrite();
1365 def.getDataType().setRequired(newNotNull);
1366 try {
1367 mmb.getStorageManager().change(def);
1369 CloudModel cloudmodel = ModelsManager.getModel("default");
1370 if (cloudmodel != null) {
1371 CloudModelBuilder cloudmodelbuilder = cloudmodel.getModelBuilder(builder);
1372 if (cloudmodelbuilder != null) cloudmodelbuilder.setBuilderDBNotNull(fieldname,value);
1373 }
1374 } catch (StorageException se) {
1376 def.getDataType().setRequired(oldNotNull);
1377 throw se;
1378 } finally {
1379 def.finish();
1380 }
1381 }
1382 }
1383 }
1384
1385
1388 public void addBuilderField(Map vars) {
1389 if (kioskmode) {
1390 log.warn("Refused add builder field, am in kiosk mode");
1391 return;
1392 }
1393 String builder = (String )vars.get("BUILDER");
1394 MMObjectBuilder bul = getMMObject(builder);
1395 if (bul != null) {
1396 int pos = bul.getFields(NodeManager.ORDER_CREATE).size() + 1;
1400
1401
1402 String fieldName = (String )vars.get("dbname");
1403 String guiType = (String )vars.get("guitype");
1404 int type = Fields.getType((String )vars.get("mmbasetype"));
1405 int itemListType = Fields.getType((String )vars.get("mmbasetype"));
1406 int state = Fields.getState((String )vars.get("dbstate"));
1407
1408 log.service("Adding field " + fieldName);
1409 DataType dataType;
1410 if (type == Field.TYPE_LIST) {
1411 dataType = DataTypes.getListDataTypeInstance(guiType, itemListType);
1412 } else {
1413 dataType = DataTypes.getDataTypeInstance(guiType, type);
1414 }
1415 log.debug("Found datatype " + dataType);
1416
1417 CoreField def = Fields.createField(fieldName, type, itemListType, state, dataType);
1418 def.setListPosition(pos);
1419 def.setEditPosition(pos);
1420
1421 def.setParent(bul);
1422 def.setStoragePosition(pos);
1423
1424 String value = (String )vars.get("dbnotnull");
1425 def.getDataType().setRequired(value.equals("true"));
1426
1427 value = (String )vars.get("dbkey");
1428 def.setUnique(value.equals("true"));
1429
1430
1431 value = (String )vars.get("dbsize");
1432 try {
1433 int i = Integer.parseInt(value);
1434 def.setMaxLength(i);
1435 } catch (Exception e) {
1436 log.debug("dbsize had invalid value, not setting size");
1437 }
1438
1439 log.debug("Found field definition " + def);
1440
1441 log.trace("Adding to storage");
1442 mmb.getStorageManager().create(def);
1444 log.trace("Adding to builder");
1445 bul.addField(def);
1447
1448 CloudModel cloudmodel = ModelsManager.getModel("default");
1449 if (cloudmodel != null) {
1450 log.debug("Calling cloud module builder");
1451 CloudModelBuilder cloudmodelbuilder = cloudmodel.getModelBuilder(builder);
1452 if (cloudmodelbuilder != null) {
1453 cloudmodelbuilder.addField(pos,fieldName, (String )vars.get("mmbasetype"), (String )vars.get("guitype"), (String )vars.get("dbstate"), (String )vars.get("dbnotnull"), (String )vars.get("dbkey"), (String )vars.get("dbsize"));
1454 }
1455 } else {
1456 log.warn("No cloud model 'default' found");
1457 }
1458 def.finish();
1459 } else {
1460 log.service("Cannot add field to builder " + builder + " because it could not be found");
1461 }
1462 }
1463
1464
1467 public void removeBuilderField(Hashtable vars) {
1468 if (kioskmode) {
1469 log.warn("Refused remove builder field, am in kiosk mode");
1470 return;
1471 }
1472 String builder = (String )vars.get("BUILDER");
1473 String fieldname = (String )vars.get("FIELDNAME");
1474 String value = (String )vars.get("SURE");
1475
1476 MMObjectBuilder bul = getMMObject(builder);
1477 if (bul != null && value != null && value.equals("Yes")) {
1478
1479 CoreField def = bul.getField(fieldname);
1480 mmb.getStorageManager().delete(def);
1482 bul.removeField(fieldname);
1484
1485 CloudModel cloudmodel = ModelsManager.getModel("default");
1486 if (cloudmodel != null) {
1487 CloudModelBuilder cloudmodelbuilder = cloudmodel.getModelBuilder(builder);
1488 if (cloudmodelbuilder != null) cloudmodelbuilder.removeField(fieldname);
1489 }
1490 def.finish();
1491 }
1492 }
1493
1494
1497 public void syncBuilderXML(MMObjectBuilder bul, String builder) {
1498 String savepath =
1499 MMBaseContext.getConfigPath() + "/builders/" + builder + ".xml";
1500 log.service("Syncing builder xml (" + savepath + ") for builder " + builder);
1501 try {
1502 BuilderWriter builderOut = new BuilderWriter(bul);
1503 builderOut.setIncludeComments(false);
1504 builderOut.setExpandBuilder(false);
1505 builderOut.writeToFile(savepath);
1506 } catch (Exception e) {
1507 log.error(Logging.stackTrace(e));
1508 }
1509 }
1510
1511
1514 public void syncModuleXML(Module mod, String modname) {
1515 String savepath =
1516 MMBaseContext.getConfigPath() + File.separator + "modules" + File.separator + modname + ".xml";
1517 try {
1518 ModuleWriter moduleOut = new ModuleWriter(mod);
1519 moduleOut.setIncludeComments(false);
1520 moduleOut.writeToFile(savepath);
1521 } catch (Exception e) {
1522 log.error(Logging.stackTrace(e));
1523 }
1524 }
1525
1526
1529 public Vector getMultilevelCacheEntries() {
1530 Vector results = new Vector();
1531 Iterator res = MultilevelCache.getCache().entrySet().iterator();
1532 while (res.hasNext()) {
1533 Map.Entry entry = (Map.Entry)res.next();
1534
1561 results.add(entry.getKey());
1562 results.add("" + MultilevelCache.getCache().getCount(entry.getKey()));
1563 }
1564 return results;
1565 }
1566
1567
1570 public Vector getNodeCacheEntries() {
1571 Vector results = new Vector();
1572 Iterator iter = NodeCache.getCache().entrySet().iterator();
1573 while (iter.hasNext()) {
1574 MMObjectNode node = (MMObjectNode)iter.next();
1575 results.add("" + NodeCache.getCache().getCount(node.getIntegerValue("number")));
1576 results.add("" + node.getIntValue("number"));
1577 results.add(node.getStringValue("owner"));
1578 results.add(mmb.getTypeDef().getValue(node.getIntValue("otype")));
1579 }
1580 return results;
1581 }
1582
1583}
1584 |
Popular Tags |
Java API By Example, From Geeks To Geeks.