Java > Open Source Codes > org > apache > catalina > mbeans > MBeanFactory


1 /*
2  * Licensed to the Apache Software Foundation (ASF) under one or more
3  * contributor license agreements. See the NOTICE file distributed with
4  * this work for additional information regarding copyright ownership.
5  * The ASF licenses this file to You under the Apache License, Version 2.0
6  * (the "License"); you may not use this file except in compliance with
7  * the License. You may obtain a copy of the License at
8  *
9  * http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17
18 package org.apache.catalina.mbeans;
19
20 import java.io.File ;
21 import java.util.Vector ;
22
23 import javax.management.MBeanException ;
24 import javax.management.MBeanServer ;
25 import javax.management.ObjectName ;
26 import javax.management.RuntimeOperationsException ;
27
28 import org.apache.catalina.Context;
29 import org.apache.catalina.Engine;
30 import org.apache.catalina.Host;
31 import org.apache.catalina.Server;
32 import org.apache.catalina.ServerFactory;
33 import org.apache.catalina.Service;
34 import org.apache.catalina.Valve;
35 import org.apache.catalina.authenticator.SingleSignOn;
36 import org.apache.catalina.connector.Connector;
37 import org.apache.catalina.core.ContainerBase;
38 import org.apache.catalina.core.StandardContext;
39 import org.apache.catalina.core.StandardEngine;
40 import org.apache.catalina.core.StandardHost;
41 import org.apache.catalina.core.StandardService;
42 import org.apache.catalina.loader.WebappLoader;
43 import org.apache.catalina.realm.DataSourceRealm;
44 import org.apache.catalina.realm.JDBCRealm;
45 import org.apache.catalina.realm.JNDIRealm;
46 import org.apache.catalina.realm.MemoryRealm;
47 import org.apache.catalina.realm.UserDatabaseRealm;
48 import org.apache.catalina.session.StandardManager;
49 import org.apache.catalina.startup.ContextConfig;
50 import org.apache.catalina.startup.HostConfig;
51 import org.apache.catalina.valves.AccessLogValve;
52 import org.apache.catalina.valves.RemoteAddrValve;
53 import org.apache.catalina.valves.RemoteHostValve;
54 import org.apache.catalina.valves.RequestDumperValve;
55 import org.apache.catalina.valves.ValveBase;
56 import org.apache.tomcat.util.modeler.BaseModelMBean;
57 import org.apache.tomcat.util.modeler.Registry;
58
59
60 /**
61  * <p>A <strong>ModelMBean</strong> implementation for the
62  * <code>org.apache.catalina.core.StandardServer</code> component.</p>
63  *
64  * @author Amy Roh
65  * @version $Revision: 467222 $ $Date: 2006-10-24 05:17:11 +0200 (mar., 24 oct. 2006) $
66  */
67
68 public class MBeanFactory extends BaseModelMBean {
69
70     private static org.apache.commons.logging.Log log =
71         org.apache.commons.logging.LogFactory.getLog(MBeanFactory.class);
72
73     /**
74      * The <code>MBeanServer</code> for this application.
75      */
76     private static MBeanServer mserver = MBeanUtils.createServer();
77
78     /**
79      * The configuration information registry for our managed beans.
80      */
81     private static Registry registry = MBeanUtils.createRegistry();
82
83
84     // ----------------------------------------------------------- Constructors
85
86
87     /**
88      * Construct a <code>ModelMBean</code> with default
89      * <code>ModelMBeanInfo</code> information.
90      *
91      * @exception MBeanException if the initializer of an object
92      * throws an exception
93      * @exception RuntimeOperationsException if an IllegalArgumentException
94      * occurs
95      */
96     public MBeanFactory()
97         throws MBeanException , RuntimeOperationsException {
98
99         super();
100
101     }
102
103
104     // ------------------------------------------------------------- Attributes
105
106
107
108
109     // ------------------------------------------------------------- Operations
110
111
112     /**
113      * Return the managed bean definition for the specified bean type
114      *
115      * @param type MBean type
116      */
117     public String findObjectName(String type) {
118
119         if (type.equals("org.apache.catalina.core.StandardContext")) {
120             return "StandardContext";
121         } else if (type.equals("org.apache.catalina.core.StandardEngine")) {
122             return "Engine";
123         } else if (type.equals("org.apache.catalina.core.StandardHost")) {
124             return "Host";
125         } else {
126             return null;
127         }
128
129     }
130
131
132     /**
133      * Little convenience method to remove redundant code
134      * when retrieving the path string
135      *
136      * @param t path string
137      * @return empty string if t==null || t.equals("/")
138      */
139     private final String getPathStr(String t) {
140         if (t == null || t.equals("/")) {
141             return "";
142         }
143         return t;
144     }
145     
146    /**
147      * Get Parent ContainerBase to add its child component
148      * from parent's ObjectName
149      */
150     private ContainerBase getParentContainerFromParent(ObjectName pname)
151         throws Exception {
152         
153         String type = pname.getKeyProperty("type");
154         String j2eeType = pname.getKeyProperty("j2eeType");
155         Service service = getService(pname);
156         StandardEngine engine = (StandardEngine) service.getContainer();
157         if ((j2eeType!=null) && (j2eeType.equals("WebModule"))) {
158             String name = pname.getKeyProperty("name");
159             name = name.substring(2);
160             int i = name.indexOf("/");
161             String hostName = name.substring(0,i);
162             String path = name.substring(i);
163             Host host = (Host) engine.findChild(hostName);
164             String pathStr = getPathStr(path);
165             StandardContext context = (StandardContext)host.findChild(pathStr);
166             return context;
167         } else if (type != null) {
168             if (type.equals("Engine")) {
169                 return engine;
170             } else if (type.equals("Host")) {
171                 String hostName = pname.getKeyProperty("host");
172                 StandardHost host = (StandardHost) engine.findChild(hostName);
173                 return host;
174             }
175         }
176         return null;
177         
178     }
179
180
181     /**
182      * Get Parent ContainerBase to add its child component
183      * from child component's ObjectName as a String
184      */
185     private ContainerBase getParentContainerFromChild(ObjectName oname)
186         throws Exception {
187         
188         String hostName = oname.getKeyProperty("host");
189         String path = oname.getKeyProperty("path");
190         Service service = getService(oname);
191         StandardEngine engine = (StandardEngine) service.getContainer();
192         if (hostName == null) {
193             // child's container is Engine
194 return engine;
195         } else if (path == null) {
196             // child's container is Host
197 StandardHost host = (StandardHost) engine.findChild(hostName);
198             return host;
199         } else {
200             // child's container is Context
201 StandardHost host = (StandardHost) engine.findChild(hostName);
202             path = getPathStr(path);
203             StandardContext context = (StandardContext) host.findChild(path);
204             return context;
205         }
206     }
207
208     
209     private Service getService(ObjectName oname) throws Exception {
210     
211         String domain = oname.getDomain();
212         Server server = ServerFactory.getServer();
213         Service[] services = server.findServices();
214         StandardService service = null;
215         for (int i = 0; i < services.length; i++) {
216             service = (StandardService) services[i];
217             if (domain.equals(service.getObjectName().getDomain())) {
218                 break;
219             }
220         }
221         if (!service.getObjectName().getDomain().equals(domain)) {
222             throw new Exception ("Service with the domain is not found");
223         }
224         return service;
225
226     }
227     
228     
229     /**
230      * Create a new AccessLoggerValve.
231      *
232      * @param parent MBean Name of the associated parent component
233      *
234      * @exception Exception if an MBean cannot be created or registered
235      */
236     public String createAccessLoggerValve(String parent)
237         throws Exception {
238
239         ObjectName pname = new ObjectName (parent);
240         // Create a new AccessLogValve instance
241 AccessLogValve accessLogger = new AccessLogValve();
242         ContainerBase containerBase = getParentContainerFromParent(pname);
243         // Add the new instance to its parent component
244 containerBase.addValve(accessLogger);
245         ObjectName oname = accessLogger.getObjectName();
246         return (oname.toString());
247
248     }
249         
250
251     /**
252      * Create a new AjpConnector
253      *
254      * @param parent MBean Name of the associated parent component
255      * @param address The IP address on which to bind
256      * @param port TCP port number to listen on
257      *
258      * @exception Exception if an MBean cannot be created or registered
259      */
260     public String createAjpConnector(String parent, String address, int port)
261         throws Exception {
262
263         return createConnector(parent, address, port, true, false);
264     }
265     
266     /**
267      * Create a new DataSource Realm.
268      *
269      * @param parent MBean Name of the associated parent component
270      *
271      * @exception Exception if an MBean cannot be created or registered
272      */
273     public String createDataSourceRealm(String parent, String dataSourceName,
274         String roleNameCol, String userCredCol, String userNameCol,
275         String userRoleTable, String userTable) throws Exception {
276
277         // Create a new DataSourceRealm instance
278 DataSourceRealm realm = new DataSourceRealm();
279         realm.setDataSourceName(dataSourceName);
280         realm.setRoleNameCol(roleNameCol);
281         realm.setUserCredCol(userCredCol);
282         realm.setUserNameCol(userNameCol);
283         realm.setUserRoleTable(userRoleTable);
284         realm.setUserTable(userTable);
285
286         // Add the new instance to its parent component
287 ObjectName pname = new ObjectName (parent);
288         ContainerBase containerBase = getParentContainerFromParent(pname);
289         // Add the new instance to its parent component
290 containerBase.setRealm(realm);
291         // Return the corresponding MBean name
292 ObjectName oname = realm.getObjectName();
293         if (oname != null) {
294             return (oname.toString());
295         } else {
296             return null;
297         }
298
299     }
300
301     /**
302      * Create a new HttpConnector
303      *
304      * @param parent MBean Name of the associated parent component
305      * @param address The IP address on which to bind
306      * @param port TCP port number to listen on
307      *
308      * @exception Exception if an MBean cannot be created or registered
309      */
310     public String createHttpConnector(String parent, String address, int port)
311         throws Exception {
312     return createConnector(parent, address, port, false, false);
313     }
314
315     /**
316      * Create a new Connector
317      *
318      * @param parent MBean Name of the associated parent component
319      * @param address The IP address on which to bind
320      * @param port TCP port number to listen on
321      * @param isAjp Create a AJP/1.3 Connector
322      * @param isSSL Create a secure Connector
323      *
324      * @exception Exception if an MBean cannot be created or registered
325      */
326     private String createConnector(String parent, String address, int port, boolean isAjp, boolean isSSL)
327         throws Exception {
328         Connector retobj = new Connector();
329         if ((address!=null) && (address.length()>0)) {
330             retobj.setProperty("address", address);
331         }
332         // Set port number
333 retobj.setPort(port);
334         // Set the protocol
335 retobj.setProtocol(isAjp ? "AJP/1.3" : "HTTP/1.1");
336         // Set SSL
337 retobj.setSecure(isSSL);
338         retobj.setScheme(isSSL ? "https" : "http");
339         // Add the new instance to its parent component
340 // FIX ME - addConnector will fail
341 ObjectName pname = new ObjectName (parent);
342         Service service = getService(pname);
343         service.addConnector(retobj);
344         
345         // Return the corresponding MBean name
346 ObjectName coname = retobj.getObjectName();
347         
348         return (coname.toString());
349     }
350
351
352     /**
353      * Create a new HttpsConnector
354      *
355      * @param parent MBean Name of the associated parent component
356      * @param address The IP address on which to bind
357      * @param port TCP port number to listen on
358      *
359      * @exception Exception if an MBean cannot be created or registered
360      */
361     public String createHttpsConnector(String parent, String address, int port)
362         throws Exception {
363         return createConnector(parent, address, port, false, true);
364     }
365
366     /**
367      * Create a new JDBC Realm.
368      *
369      * @param parent MBean Name of the associated parent component
370      *
371      * @exception Exception if an MBean cannot be created or registered
372      */
373     public String createJDBCRealm(String parent, String driverName,
374         String connectionName, String connectionPassword, String connectionURL)
375         throws Exception {
376
377         // Create a new JDBCRealm instance
378 JDBCRealm realm = new JDBCRealm();
379         realm.setDriverName(driverName);
380         realm.setConnectionName(connectionName);
381         realm.setConnectionPassword(connectionPassword);
382         realm.setConnectionURL(connectionURL);
383
384         // Add the new instance to its parent component
385 ObjectName pname = new ObjectName (parent);
386         ContainerBase containerBase = getParentContainerFromParent(pname);
387         // Add the new instance to its parent component
388 containerBase.setRealm(realm);
389         // Return the corresponding MBean name
390 ObjectName oname = realm.getObjectName();
391
392         if (oname != null) {
393             return (oname.toString());
394         } else {
395             return null;
396         }
397
398     }
399
400
401     /**
402      * Create a new JNDI Realm.
403      *
404      * @param parent MBean Name of the associated parent component
405      *
406      * @exception Exception if an MBean cannot be created or registered
407      */
408     public String createJNDIRealm(String parent)
409         throws Exception {
410
411          // Create a new JNDIRealm instance
412 JNDIRealm realm = new JNDIRealm();
413
414         // Add the new instance to its parent component
415 ObjectName pname = new ObjectName (parent);
416         ContainerBase containerBase = getParentContainerFromParent(pname);
417         // Add the new instance to its parent component
418 containerBase.setRealm(realm);
419         // Return the corresponding MBean name
420 ObjectName oname = realm.getObjectName();
421
422         if (oname != null) {
423             return (oname.toString());
424         } else {
425             return null;
426         }
427
428
429     }
430
431
432     /**
433      * Create a new Memory Realm.
434      *
435      * @param parent MBean Name of the associated parent component
436      *
437      * @exception Exception if an MBean cannot be created or registered
438      */
439     public String createMemoryRealm(String parent)
440         throws Exception {
441
442          // Create a new MemoryRealm instance
443 MemoryRealm realm = new MemoryRealm();
444
445         // Add the new instance to its parent component
446 ObjectName pname = new ObjectName (parent);
447         ContainerBase containerBase = getParentContainerFromParent(pname);
448         // Add the new instance to its parent component
449 containerBase.setRealm(realm);
450         // Return the corresponding MBean name
451 ObjectName oname = realm.getObjectName();
452         if (oname != null) {
453             return (oname.toString());
454         } else {
455             return null;
456         }
457
458     }
459
460
461     /**
462      * Create a new Remote Address Filter Valve.
463      *
464      * @param parent MBean Name of the associated parent component
465      *
466      * @exception Exception if an MBean cannot be created or registered
467      */
468     public String createRemoteAddrValve(String parent)
469         throws Exception {
470
471         // Create a new RemoteAddrValve instance
472 RemoteAddrValve valve = new RemoteAddrValve();
473
474         // Add the new instance to its parent component
475 ObjectName pname = new ObjectName (parent);
476         ContainerBase containerBase = getParentContainerFromParent(pname);
477         containerBase.addValve(valve);
478         ObjectName oname = valve.getObjectName();
479         return (oname.toString());
480
481     }
482
483
484      /**
485      * Create a new Remote Host Filter Valve.
486      *
487      * @param parent MBean Name of the associated parent component
488      *
489      * @exception Exception if an MBean cannot be created or registered
490      */
491     public String createRemoteHostValve(String parent)
492         throws Exception {
493
494         // Create a new RemoteHostValve instance
495 RemoteHostValve valve = new RemoteHostValve();
496
497         // Add the new instance to its parent component
498 ObjectName pname = new ObjectName (parent);
499         ContainerBase containerBase = getParentContainerFromParent(pname);
500         containerBase.addValve(valve);
501         ObjectName oname = valve.getObjectName();
502         return (oname.toString());
503         
504     }
505
506
507     /**
508      * Create a new Request Dumper Valve.
509      *
510      * @param parent MBean Name of the associated parent component
511      *
512      * @exception Exception if an MBean cannot be created or registered
513      */
514     public String createRequestDumperValve(String parent)
515         throws Exception {
516
517         // Create a new RequestDumperValve instance
518 RequestDumperValve valve = new RequestDumperValve();
519
520         // Add the new instance to its parent component
521 ObjectName pname = new ObjectName (parent);
522         ContainerBase containerBase = getParentContainerFromParent(pname);
523         containerBase.addValve(valve);
524         ObjectName oname = valve.getObjectName();
525         return (oname.toString());
526
527     }
528
529
530     /**
531      * Create a new Single Sign On Valve.
532      *
533      * @param parent MBean Name of the associated parent component
534      *
535      * @exception Exception if an MBean cannot be created or registered
536      */
537     public String createSingleSignOn(String parent)
538         throws Exception {
539
540         // Create a new SingleSignOn instance
541 SingleSignOn valve = new SingleSignOn();
542
543         // Add the new instance to its parent component
544 ObjectName pname = new ObjectName (parent);
545         ContainerBase containerBase = getParentContainerFromParent(pname);
546         containerBase.addValve(valve);
547         ObjectName oname = valve.getObjectName();
548         return (oname.toString());
549
550     }
551     
552     
553    /**
554      * Create a new StandardContext.
555      *
556      * @param parent MBean Name of the associated parent component
557      * @param path The context path for this Context
558      * @param docBase Document base directory (or WAR) for this Context
559      *
560      * @exception Exception if an MBean cannot be created or registered
561      */
562     public String createStandardContext(String parent,
563                                         String path,
564                                         String docBase)
565         throws Exception {
566                                             
567         // XXX for backward compatibility. Remove it once supported by the admin
568 return
569             createStandardContext(parent,path,docBase,false,false,false,false);
570     }
571
572     /**
573      * Given a context path, get the config file name.
574      */
575     private String getConfigFile(String path) {
576         String basename = null;
577         if (path.equals("")) {
578             basename = "ROOT";
579         } else {
580             basename = path.substring(1).replace('/', '#');
581         }
582         return (basename);
583     }
584
585    /**
586      * Create a new StandardContext.
587      *
588      * @param parent MBean Name of the associated parent component
589      * @param path The context path for this Context
590      * @param docBase Document base directory (or WAR) for this Context
591      *
592      * @exception Exception if an MBean cannot be created or registered
593      */
594     public String createStandardContext(String parent,
595                                         String path,
596                                         String docBase,
597                                         boolean xmlValidation,
598                                         boolean xmlNamespaceAware,
599                                         boolean tldValidation,
600                                         boolean tldNamespaceAware)
601         throws Exception {
602
603         // Create a new StandardContext instance
604 StandardContext context = new StandardContext();
605         path = getPathStr(path);
606         context.setPath(path);
607         context.setDocBase(docBase);
608         context.setXmlValidation(xmlValidation);
609         context.setXmlNamespaceAware(xmlNamespaceAware);
610         context.setTldValidation(tldValidation);
611         context.setTldNamespaceAware(tldNamespaceAware);
612         
613         ContextConfig contextConfig = new ContextConfig();
614         context.addLifecycleListener(contextConfig);
615
616         // Add the new instance to its parent component
617 ObjectName pname = new ObjectName (parent);
618         ObjectName deployer = new ObjectName (pname.getDomain()+
619                                              ":type=Deployer,host="+
620                                              pname.getKeyProperty("host"));
621         if(mserver.isRegistered(deployer)) {
622             String contextPath = context.getPath();
623             mserver.invoke(deployer, "addServiced",
624                            new Object [] {contextPath},
625                            new String [] {"java.lang.String"});
626             String configPath = (String )mserver.getAttribute(deployer,
627                                                              "configBaseName");
628             String baseName = getConfigFile(contextPath);
629             File configFile = new File (new File (configPath), baseName+".xml");
630             context.setConfigFile(configFile.getAbsolutePath());
631             mserver.invoke(deployer, "manageApp",
632                            new Object [] {context},
633                            new String [] {"org.apache.catalina.Context"});
634             mserver.invoke(deployer, "removeServiced",
635                            new Object [] {contextPath},
636                            new String [] {"java.lang.String"});
637         } else {
638             log.warn("Deployer not found for "+pname.getKeyProperty("host"));
639             Service service = getService(pname);
640             Engine engine = (Engine) service.getContainer();
641             Host host = (Host) engine.findChild(pname.getKeyProperty("host"));
642             host.addChild(context);
643         }
644
645         // Return the corresponding MBean name
646 ObjectName oname = context.getJmxName();
647
648         return (oname.toString());
649
650     }
651
652
653    /**
654      * Create a new StandardEngine.
655      *
656      * @param parent MBean Name of the associated parent component
657      * @param engineName Unique name of this Engine
658      * @param defaultHost Default hostname of this Engine
659      * @param serviceName Unique name of this Service
660      *
661      * @exception Exception if an MBean cannot be created or registered
662      */
663
664     public Vector createStandardEngineService(String parent,
665             String engineName, String defaultHost, String serviceName)
666         throws Exception {
667
668         // Create a new StandardService instance
669 StandardService service = new StandardService();
670         service.setName(serviceName);
671         // Create a new StandardEngine instance
672 StandardEngine engine = new StandardEngine();
673         engine.setName(engineName);
674         engine.setDefaultHost(defaultHost);
675         // Need to set engine before adding it to server in order to set domain
676 service.setContainer(engine);
677         // Add the new instance to its parent component
678 Server server = ServerFactory.getServer();
679         server.addService(service);
680         Vector onames = new Vector ();
681         // FIXME service & engine.getObjectName
682 //ObjectName oname = engine.getObjectName();
683 ObjectName oname =
684             MBeanUtils.createObjectName(engineName, engine);
685         onames.add(0, oname);
686         //oname = service.getObjectName();
687 oname =
688             MBeanUtils.createObjectName(engineName, service);
689         onames.add(1, oname);
690         return (onames);
691
692     }
693
694
695     /**
696      * Create a new StandardHost.
697      *
698      * @param parent MBean Name of the associated parent component
699      * @param name Unique name of this Host
700      * @param appBase Application base directory name
701      * @param autoDeploy Should we auto deploy?
702      * @param deployOnStartup Deploy on server startup?
703      * @param deployXML Should we deploy Context XML config files property?
704      * @param unpackWARs Should we unpack WARs when auto deploying?
705      * @param xmlNamespaceAware Should we turn on/off XML namespace awareness?
706      * @param xmlValidation Should we turn on/off XML validation?
707      *
708      * @exception Exception if an MBean cannot be created or registered
709      */
710     public String createStandardHost(String parent, String name,
711                                      String appBase,
712                                      boolean autoDeploy,
713                                      boolean deployOnStartup,
714                                      boolean deployXML,
715                                      boolean unpackWARs,
716                                      boolean xmlNamespaceAware,
717                                      boolean xmlValidation)
718         throws Exception {
719
720         // Create a new StandardHost instance
721 StandardHost host = new StandardHost();
722         host.setName(name);
723         host.setAppBase(appBase);
724         host.setAutoDeploy(autoDeploy);
725         host.setDeployOnStartup(deployOnStartup);
726         host.setDeployXML(deployXML);
727         host.setUnpackWARs(unpackWARs);
728         host.setXmlNamespaceAware(xmlNamespaceAware);
729         host.setXmlValidation(xmlValidation);
730     
731         // add HostConfig for active reloading
732 HostConfig hostConfig = new HostConfig();
733         host.addLifecycleListener(hostConfig);
734
735         // Add the new instance to its parent component
736 ObjectName pname = new ObjectName (parent);
737         Service service = getService(pname);
738         Engine engine = (Engine) service.getContainer();
739         engine.addChild(host);
740
741         // Return the corresponding MBean name
742 return (host.getObjectName().toString());
743
744     }
745
746
747     /**
748      * Create a new StandardManager.
749      *
750      * @param parent MBean Name of the associated parent component
751      *
752      * @exception Exception if an MBean cannot be created or registered
753      */
754     public