KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > sun > enterprise > admin > wsmgmt > repository > impl > AppServRepositoryProvider


1 /*
2  * The contents of this file are subject to the terms
3  * of the Common Development and Distribution License
4  * (the License). You may not use this file except in
5  * compliance with the License.
6  *
7  * You can obtain a copy of the license at
8  * https://glassfish.dev.java.net/public/CDDLv1.0.html or
9  * glassfish/bootstrap/legal/CDDLv1.0.txt.
10  * See the License for the specific language governing
11  * permissions and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL
14  * Header Notice in each file and include the License file
15  * at glassfish/bootstrap/legal/CDDLv1.0.txt.
16  * If applicable, add the following below the CDDL Header,
17  * with the fields enclosed by brackets [] replaced by
18  * you own identifying information:
19  * "Portions Copyrighted [year] [name of copyright owner]"
20  *
21  * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
22  */

23 package com.sun.enterprise.admin.wsmgmt.repository.impl;
24
25 import java.io.File JavaDoc;
26 import java.io.FileInputStream JavaDoc;
27 import java.util.Map JavaDoc;
28 import java.util.HashMap JavaDoc;
29 import java.util.Collection JavaDoc;
30 import java.util.Iterator JavaDoc;
31 import java.util.List JavaDoc;
32 import com.sun.enterprise.util.io.FileUtils;
33 import com.sun.enterprise.util.RelativePathResolver;
34 import com.sun.enterprise.config.ConfigContext;
35 import com.sun.enterprise.config.serverbeans.EjbModule;
36 import com.sun.enterprise.config.serverbeans.WebModule;
37 import com.sun.enterprise.config.serverbeans.ApplicationHelper;
38 import com.sun.enterprise.admin.server.core.AdminService;
39 import com.sun.enterprise.deployment.Application;
40 import com.sun.enterprise.deployment.BundleDescriptor;
41 import com.sun.enterprise.deployment.util.ModuleDescriptor;
42 import com.sun.enterprise.util.SystemPropertyConstants;
43 import com.sun.enterprise.admin.servermgmt.pe.PEFileLayout;
44 import javax.enterprise.deploy.shared.ModuleType JavaDoc;
45 import com.sun.enterprise.deployment.io.ApplicationDeploymentDescriptorFile;
46 import com.sun.enterprise.admin.wsmgmt.repository.spi.WebServiceInfoProvider;
47 import com.sun.enterprise.admin.wsmgmt.repository.spi.RepositoryProvider;
48 import com.sun.enterprise.admin.wsmgmt.repository.impl.cache.CacheMgr;
49 import com.sun.enterprise.admin.wsmgmt.repository.impl.cache.J2eeApplication;
50 import com.sun.enterprise.admin.wsmgmt.repository.spi.RepositoryException;
51
52 import java.util.logging.Logger JavaDoc;
53 import java.util.logging.Level JavaDoc;
54 import com.sun.logging.LogDomains;
55
56 /**
57  * This is the mechanism to provide web service crawling. A RepositoryProvider
58  * implementation is a class that extends the RepositoryProvider abstract class.
59  * <br>
60  * A RepositoryProvider implemented is identified by its fully qualified class
61  * name. The default RepositoryProvider is
62  * com.sun.enterprise.admin.repository.spi.impl.ApplicationServerProvider
63  */

64 public class AppServRepositoryProvider implements RepositoryProvider {
65
66     /**
67      * Constructor.
68      */

69     public AppServRepositoryProvider() {
70         if (instanceRoot == null) {
71             instanceRoot = System.getProperty(
72                 SystemPropertyConstants.INSTANCE_ROOT_PROPERTY);
73         }
74     }
75
76     /**
77      * Returns the unique identifier for this RepositoryProvider object.
78      *
79      * @return fully qualified class name of this RepositoryProvider
80      */

81     public String JavaDoc getProviderID() {
82         return PROVIDER_ID;
83     }
84
85     /**
86      * Returns the map of module descriptor locations that contains web service
87      * implementation and assciated properties.
88      *
89      * @return the map of module information
90      */

91     public Map JavaDoc getWebServiceModules() {
92         Map JavaDoc map = new HashMap JavaDoc();
93
94         // admin config context
95
ConfigContext configCtx = AdminService.getAdminService().
96                         getAdminContext().getAdminConfigContext();
97
98         CacheMgr mgr = CacheMgr.getInstance();
99
100         // j2ee application
101
Map JavaDoc apps = mgr.getJ2eeApplications();
102         Collection JavaDoc aValues = apps.values();
103         for (Iterator JavaDoc iter=aValues.iterator(); iter.hasNext();) {
104             J2eeApplication app = (J2eeApplication) iter.next();
105
106             // ejb bundles
107
List JavaDoc ejbBundles = app.getEjbBundles();
108             if (ejbBundles != null) {
109                 for (Iterator JavaDoc itr=ejbBundles.iterator(); itr.hasNext();) {
110                     String JavaDoc ejb = (String JavaDoc) itr.next();
111                     try {
112                         Map JavaDoc m = getEjbBundleInfo(configCtx, app.getName(), ejb);
113                         map.put(m.get(WebServiceInfoProvider.
114                             SUN_EJB_JAR_XML_LOCATION_PROP_NAME), m);
115                     } catch (RepositoryException re) { }
116                 }
117             }
118
119             // web bundles
120
List JavaDoc webBundles = app.getWebBundles();
121             if (webBundles != null) {
122                 for (Iterator JavaDoc itr=webBundles.iterator(); itr.hasNext();) {
123                     String JavaDoc web = (String JavaDoc) itr.next();
124                     try {
125                         Map JavaDoc m = getWebBundleInfo(configCtx, app.getName(), web);
126                         map.put(m.get(WebServiceInfoProvider.
127                             SUN_WEB_XML_LOCATION_PROP_NAME), m);
128                     } catch (RepositoryException re) { }
129                 }
130             }
131         }
132
133         // stand alone ejb module
134
Map JavaDoc ejbs = mgr.getEjbModules();
135         Collection JavaDoc eValues = ejbs.values();
136         for (Iterator JavaDoc iter=eValues.iterator(); iter.hasNext();) {
137             String JavaDoc ejbMod = (String JavaDoc) iter.next();
138             try {
139                 Map JavaDoc m = getEjbModuleInfo(configCtx, ejbMod);
140                 map.put(m.get(WebServiceInfoProvider.
141                     SUN_EJB_JAR_XML_LOCATION_PROP_NAME), m);
142             } catch (RepositoryException re) { }
143         }
144
145         // stand alone web module
146
Map JavaDoc webs = mgr.getWebModules();
147         Collection JavaDoc wValues = webs.values();
148         for (Iterator JavaDoc iter=wValues.iterator(); iter.hasNext();) {
149             String JavaDoc webMod = (String JavaDoc) iter.next();
150
151             try {
152                 Map JavaDoc m = getWebModuleInfo(configCtx, webMod);
153                 map.put(m.get(WebServiceInfoProvider.
154                     SUN_WEB_XML_LOCATION_PROP_NAME), m);
155             } catch (RepositoryException re) { }
156         }
157
158         return map;
159     }
160
161     /**
162      * Returns alt-dd or null for the bundle.
163      *
164      * @param bundleName name of the bundle
165      * @param appXML path to the application.xml
166      * @param ejbBundle true if an ejb bundle
167      */

168     private String JavaDoc getAltDD(String JavaDoc bundleName, String JavaDoc appXML,
169             boolean ejbBundle) {
170
171         String JavaDoc altDD = null;
172         FileInputStream JavaDoc fis = null;
173         try {
174             // abort if application.xml file does not exist
175
File JavaDoc f = new File JavaDoc(appXML);
176             if (!f.exists() || (bundleName==null)) {
177                 return null;
178             }
179
180             ApplicationDeploymentDescriptorFile addf =
181                 new ApplicationDeploymentDescriptorFile();
182             fis = new FileInputStream JavaDoc(f);
183             Application app = (Application) addf.read(fis);
184             for (Iterator JavaDoc itr=app.getModules();itr.hasNext();) {
185                 ModuleDescriptor md = (ModuleDescriptor) itr.next();
186                 String JavaDoc uri = md.getArchiveUri();
187                 if (bundleName.equals(uri)) {
188                     altDD = md.getAlternateDescriptor();
189                     break;
190                 }
191             }
192         } catch (Exception JavaDoc e) {
193             _logger.log(Level.FINE, "Error while reading alt-dd", e);
194         } finally {
195             if (fis != null) {
196                 try {
197                     fis.close();
198                 } catch (Exception JavaDoc e) { }
199             }
200         }
201
202         return altDD;
203     }
204
205     /**
206      * Returns path information for an ejb bundle.
207      * This is an embedded module within an application.
208      *
209      * @param ctx config context
210      * @param name name of the application
211      * @param bundleName ejb bundle name
212      *
213      * @return path information for an ejb bundle
214      */

215     private Map JavaDoc getEjbBundleInfo(ConfigContext ctx, String JavaDoc name,
216             String JavaDoc bundleName) throws RepositoryException {
217             
218         // validate mandatory arguments
219
if ( (bundleName == null) || (ctx == null) || (name == null) ) {
220             throw new IllegalArgumentException JavaDoc();
221         }
222
223         Map JavaDoc map = new HashMap JavaDoc();
224
225         try {
226             // module type is EJB
227
map.put(WebServiceInfoProvider.MOD_TYPE_PROP_NAME,
228                             WebServiceInfoProvider.MOD_TYPE_EJB);
229
230             // application id
231
map.put(WebServiceInfoProvider.APP_ID_PROP_NAME, name);
232
233             // bundle name
234
map.put(WebServiceInfoProvider.BUNDLE_NAME_PROP_NAME, bundleName);
235
236             // APP_ROOT_LOCATION is not used
237
// config bean
238
//com.sun.enterprise.config.serverbeans.J2eeApplication app =
239
// (com.sun.enterprise.config.serverbeans.J2eeApplication)
240
// ApplicationHelper.findApplication(ctx, name);
241
//
242
// applications/j2ee-applications/appName
243
//String appRoot =
244
// RelativePathResolver.resolvePath(app.getLocation());
245
//map.put(WebServiceInfoProvider.APP_ROOT_LOCATION_PROP_NAME,
246
// appRoot);
247

248             // generated/xml/j2ee-applications/<app-name>
249
String JavaDoc xmlDir = instanceRoot
250                 + File.separator + PEFileLayout.GENERATED_DIR
251                 + File.separator + PEFileLayout.XML_DIR
252                 + File.separator + PEFileLayout.J2EE_APPS_DIR
253                 + File.separator + name;
254
255             // generated/xml/j2ee-applications/<app-name>/bundleName
256
String JavaDoc bundleRoot = xmlDir + File.separator
257                        + FileUtils.makeFriendlyFileName(bundleName);
258             map.put(WebServiceInfoProvider.BUNDLE_ROOT_LOCATION_PROP_NAME,
259                     bundleRoot);
260
261             String JavaDoc ejbXML = null;
262             String JavaDoc sunEjbXML = null;
263             
264             // generated/xml/j2ee-applications/appName/META-INF/application.xml
265
String JavaDoc appXML = xmlDir +File.separator + META_INF
266                           + File.separator + APPLICATION_XML;
267             map.put(WebServiceInfoProvider.APPLICATION_XML_PROP_NAME,
268                     getFormattedFileContents(appXML));
269             String JavaDoc altDD = getAltDD(bundleName, appXML, true);
270
271             // no alt DD
272
if (altDD == null) {
273                 ejbXML = bundleRoot + File.separator + META_INF
274                        + File.separator + EJB_JAR_XML;
275
276                 sunEjbXML = bundleRoot + File.separator + META_INF
277                           + File.separator + SUN_EJB_JAR_XML;
278             } else {
279                 ejbXML = xmlDir + File.separator + altDD;
280                 sunEjbXML = xmlDir + File.separator + SUN_DASH
281                           + new File JavaDoc(ejbXML).getName();
282             }
283
284             
285             // generated/xml/j2ee-applications/appName/bundleName/META-INF/ejb-jar.xml
286
map.put(WebServiceInfoProvider.EJB_JAR_XML_PROP_NAME,
287                     getFormattedFileContents(ejbXML));
288             
289             // generated/xml/j2ee-applications/appName/bundleName/META-INF/sun-ejb-jar.xml
290
map.put(WebServiceInfoProvider.SUN_EJB_JAR_XML_LOCATION_PROP_NAME,
291                     sunEjbXML);
292             map.put(WebServiceInfoProvider.SUN_EJB_JAR_XML_PROP_NAME,
293                     getFormattedFileContents(sunEjbXML));
294
295             // generated/xml/j2ee-applications/appName/bundleName/META-INF/webservices.xml
296
String JavaDoc wsXML = bundleRoot + File.separator
297                          + META_INF + File.separator + WEBSERVICES_XML;
298             map.put(WebServiceInfoProvider.WS_XML_LOCATION_PROP_NAME, wsXML);
299             map.put(WebServiceInfoProvider.WS_XML_PROP_NAME,
300             getFormattedFileContents(wsXML));
301
302         } catch (Exception JavaDoc e) {
303             throw new RepositoryException(e);
304         }
305
306         return map;
307     }
308
309     /**
310      * Returns the path information for a web bundle.
311      * This is an embedded module within an application.
312      *
313      * @param ctx config context
314      * @param name name of the application
315      * @param bundleName name of the web bundle
316      *
317      * @return path information for a web bundle
318      */

319     private Map JavaDoc getWebBundleInfo(ConfigContext ctx, String JavaDoc name,
320             String JavaDoc bundleName) throws RepositoryException {
321
322         // validate mandatory arguments
323
if ( (bundleName == null) || (ctx == null) || (name == null) ) {
324             throw new IllegalArgumentException JavaDoc();
325         }
326
327         Map JavaDoc map = new HashMap JavaDoc();
328
329         try {
330             // module type is WEB
331
map.put(WebServiceInfoProvider.MOD_TYPE_PROP_NAME,
332                             WebServiceInfoProvider.MOD_TYPE_WEB);
333
334             // application id
335
map.put(WebServiceInfoProvider.APP_ID_PROP_NAME, name);
336
337             // bundle name
338
map.put(WebServiceInfoProvider.BUNDLE_NAME_PROP_NAME, bundleName);
339
340             // APP_ROOT_LOCATION is not used
341
// config bean
342
//com.sun.enterprise.config.serverbeans.J2eeApplication app =
343
// (com.sun.enterprise.config.serverbeans.J2eeApplication)
344
// ApplicationHelper.findApplication(ctx, name);
345
//
346
// applications/j2ee-applications/appName
347
//String appRoot =
348
// RelativePathResolver.resolvePath(app.getLocation());
349
//map.put(WebServiceInfoProvider.APP_ROOT_LOCATION_PROP_NAME,
350
// appRoot);
351

352             // generated/xml/j2ee-applications/<app-name>
353
String JavaDoc xmlDir = instanceRoot
354                 + File.separator + PEFileLayout.GENERATED_DIR
355                 + File.separator + PEFileLayout.XML_DIR
356                 + File.separator + PEFileLayout.J2EE_APPS_DIR
357                 + File.separator + name;
358
359             // generated/xml/j2ee-applications/<app-name>/bundleName
360
String JavaDoc bundleRoot = xmlDir + File.separator
361                        + FileUtils.makeFriendlyFileName(bundleName);
362             map.put(WebServiceInfoProvider.BUNDLE_ROOT_LOCATION_PROP_NAME,
363                     bundleRoot);
364
365             String JavaDoc webXML = null;
366             String JavaDoc sunWebXML = null;
367             
368             // generated/xml/j2ee-applications/appName/META-INF/application.xml
369
String JavaDoc appXML = xmlDir +File.separator + META_INF
370                           + File.separator + APPLICATION_XML;
371             map.put(WebServiceInfoProvider.APPLICATION_XML_PROP_NAME,
372                     getFormattedFileContents(appXML));
373             String JavaDoc altDD = getAltDD(bundleName, appXML, false);
374
375             // no alt DD
376
if (altDD == null) {
377                 webXML = bundleRoot + File.separator + WEB_INF
378                        + File.separator + WEB_XML;
379
380                 sunWebXML = bundleRoot + File.separator + WEB_INF
381                           + File.separator + SUN_WEB_XML;
382             } else {
383                 webXML = xmlDir + File.separator + altDD;
384                 sunWebXML = xmlDir + File.separator + SUN_DASH
385                           + new File JavaDoc(webXML).getName();
386             }
387
388             // generated/xml/j2ee-applications/appName/bundleName/WEB-INF/web.xml
389
map.put(WebServiceInfoProvider.WEB_XML_PROP_NAME,
390                     getFormattedFileContents(webXML));
391
392             // generated/xml/j2ee-applications/appName/bundleName/WEB-INF/sun-web.xml
393
map.put(WebServiceInfoProvider.SUN_WEB_XML_LOCATION_PROP_NAME,
394                     sunWebXML);
395             map.put(WebServiceInfoProvider.SUN_WEB_XML_PROP_NAME,
396                     getFormattedFileContents(sunWebXML));
397
398             // generated/xml/j2ee-applications/appName/bundleName/WEB-INF/webservices.xml
399
String JavaDoc wsXML = bundleRoot + File.separator + WEB_INF
400                          + File.separator + WEBSERVICES_XML;
401             map.put(WebServiceInfoProvider.WS_XML_LOCATION_PROP_NAME, wsXML);
402             map.put(WebServiceInfoProvider.WS_XML_PROP_NAME,
403             getFormattedFileContents(wsXML));
404
405         } catch (Exception JavaDoc e) {
406             throw new RepositoryException(e);
407         }
408
409         return map;
410     }
411
412     /**
413      * Returns path information for a stand alone ejb module.
414      *
415      * @param ctx config context
416      * @param name name of the ejb module
417      *
418      * @return path information for an ejb module
419      */

420     private Map JavaDoc getEjbModuleInfo(ConfigContext ctx, String JavaDoc name)
421             throws RepositoryException {
422             
423         // validate mandatory arguments
424
if ( (ctx == null) || (name == null) ) {
425             throw new IllegalArgumentException JavaDoc();
426         }
427
428         Map JavaDoc map = new HashMap JavaDoc();
429
430         try {
431             // module type is EJB
432
map.put(WebServiceInfoProvider.MOD_TYPE_PROP_NAME,
433                             WebServiceInfoProvider.MOD_TYPE_EJB);
434
435             // ejb module id
436
map.put(WebServiceInfoProvider.APP_ID_PROP_NAME, name);
437
438             // bundle name is empty
439
map.put(WebServiceInfoProvider.BUNDLE_NAME_PROP_NAME, null);
440
441             // APP_ROOT_LOCATION is not used
442
// ejb module config bean
443
//EjbModule ejbMod = (EjbModule)
444
// ApplicationHelper.findApplication(ctx, name);
445
//
446
// applications/j2ee-modules/moduleName
447
//String ejbModuleRoot =
448
// RelativePathResolver.resolvePath(ejbMod.getLocation());
449
//map.put(WebServiceInfoProvider.APP_ROOT_LOCATION_PROP_NAME,
450
// ejbModuleRoot);
451

452             // generated/xml/j2ee-modules/moduleName
453
String JavaDoc xmlDir = instanceRoot
454                           + File.separator + PEFileLayout.GENERATED_DIR
455                           + File.separator + PEFileLayout.XML_DIR
456                           + File.separator + PEFileLayout.J2EE_MODULES_DIR
457                           + File.separator + name;
458             map.put(WebServiceInfoProvider.BUNDLE_ROOT_LOCATION_PROP_NAME,
459                     xmlDir);
460
461             // generated/xml/j2ee-modules/moduleName/META-INF/ejb-jar.xml
462
String JavaDoc ejbXML = xmlDir + File.separator + META_INF
463                           + File.separator + EJB_JAR_XML;
464             map.put(WebServiceInfoProvider.
465                 EJB_JAR_XML_PROP_NAME, getFormattedFileContents(ejbXML));
466
467             // generated/xml/j2ee-modules/moduleName/META-INF/sun-ejb-jar.xml
468
String JavaDoc sunEjbXML = xmlDir + File.separator + META_INF
469                               + File.separator + SUN_EJB_JAR_XML;
470             map.put(WebServiceInfoProvider.SUN_EJB_JAR_XML_LOCATION_PROP_NAME,
471                     sunEjbXML);
472             map.put(WebServiceInfoProvider.
473                 SUN_EJB_JAR_XML_PROP_NAME, getFormattedFileContents(sunEjbXML));
474
475             // generated/xml/j2ee-modules/moduleName/META-INF/webservices.xml
476
String JavaDoc wsXML = xmlDir + File.separator + META_INF
477                          + File.separator + WEBSERVICES_XML;
478             map.put(WebServiceInfoProvider.WS_XML_LOCATION_PROP_NAME, wsXML);
479             map.put(WebServiceInfoProvider.WS_XML_PROP_NAME,
480             getFormattedFileContents(wsXML));
481
482         } catch (Exception JavaDoc e) {
483             throw new RepositoryException(e);
484         }
485
486         return map;
487     }
488
489     /**
490      * Returns path information for a stand alone web module.
491      *
492      * @param ctx config context
493      * @param name name of the web module
494      *
495      * @return path information for an web module
496      */

497     private Map JavaDoc getWebModuleInfo(ConfigContext ctx, String JavaDoc name)
498             throws RepositoryException {
499
500         // validate mandatory arguments
501
if ( (ctx == null) || (name == null) ) {
502             throw new IllegalArgumentException JavaDoc();
503         }
504
505         Map JavaDoc map = new HashMap JavaDoc();
506
507         try {
508             // module type is WEB
509
map.put(WebServiceInfoProvider.MOD_TYPE_PROP_NAME,
510                             WebServiceInfoProvider.MOD_TYPE_WEB);
511
512             // application id
513
map.put(WebServiceInfoProvider.APP_ID_PROP_NAME, name);
514
515             // bundle name
516
map.put(WebServiceInfoProvider.BUNDLE_NAME_PROP_NAME, null);
517
518             // APP_ROOT_LOCATION is not used
519
// config bean
520
//WebModule webapp = (WebModule)
521
// ApplicationHelper.findApplication(ctx, name);
522
//
523
// applications/j2ee-modules/moduleName
524
//String webModuleRoot =
525
// RelativePathResolver.resolvePath(webapp.getLocation());
526
//map.put(WebServiceInfoProvider.APP_ROOT_LOCATION_PROP_NAME,
527
// webModuleRoot);
528

529             // generated/xml/j2ee-modules/moduleName
530
String JavaDoc xmlDir = instanceRoot
531                           + File.separator + PEFileLayout.GENERATED_DIR
532                           + File.separator + PEFileLayout.XML_DIR
533                           + File.separator + PEFileLayout.J2EE_MODULES_DIR
534                           + File.separator + name;
535             map.put(WebServiceInfoProvider.BUNDLE_ROOT_LOCATION_PROP_NAME,
536                     xmlDir);
537
538             // generated/xml/j2ee-modules/moduleName/WEB-INF/web.xml
539
String JavaDoc webXML = xmlDir + File.separator + WEB_INF
540                           + File.separator + WEB_XML;
541             map.put(WebServiceInfoProvider.WEB_XML_PROP_NAME,
542             getFormattedFileContents(webXML));
543
544             // generated/xml/j2ee-modules/moduleName/WEB-INF/sun-web.xml
545
String JavaDoc sunWebXML = xmlDir + File.separator + WEB_INF
546                              + File.separator + SUN_WEB_XML;
547             map.put(WebServiceInfoProvider.SUN_WEB_XML_LOCATION_PROP_NAME,
548                     sunWebXML);
549             map.put(WebServiceInfoProvider.
550                 SUN_WEB_XML_PROP_NAME, getFormattedFileContents(sunWebXML));
551
552             // generated/xml/j2ee-modules/moduleName/WEB-INF/webservices.xml
553
String JavaDoc wsXML = xmlDir + File.separator + WEB_INF
554                          + File.separator + WEBSERVICES_XML;
555             map.put(WebServiceInfoProvider.WS_XML_LOCATION_PROP_NAME, wsXML);
556             map.put(WebServiceInfoProvider.WS_XML_PROP_NAME,
557             getFormattedFileContents(wsXML));
558
559         } catch (Exception JavaDoc e) {
560             throw new RepositoryException(e);
561         }
562
563         return map;
564     }
565
566     private String JavaDoc getFormattedFileContents(String JavaDoc filePath) {
567
568         String JavaDoc str = null;
569         try {
570             str = FileUtils.getFileContents(filePath);
571         } catch (Exception JavaDoc e) {
572             _logger.log(Level.FINE, "Error reading dd file contents", e);
573         }
574
575         return str;
576     }
577
578     // ---- VARIABLES - PRIVATE -----------------------------------------
579
private static final String JavaDoc WEB_INF = "WEB-INF";
580     private static final String JavaDoc META_INF = "META-INF";
581     private static final String JavaDoc WEBSERVICES_XML = "webservices.xml";
582     private static final String JavaDoc WEB_XML = "web.xml";
583     private static final String JavaDoc SUN_WEB_XML = "sun-web.xml";
584     private static final String JavaDoc EJB_JAR_XML = "ejb-jar.xml";
585     private static final String JavaDoc SUN_EJB_JAR_XML = "sun-ejb-jar.xml";
586     private static final String JavaDoc APPLICATION_XML = "application.xml";
587     private static final String JavaDoc SUN_DASH = "sun-";
588     private static String JavaDoc instanceRoot = null;
589     private static Logger JavaDoc _logger = Logger.getLogger(LogDomains.ADMIN_LOGGER);
590
591     /** provider id for the default RepositoryProvider */
592     public static final String JavaDoc PROVIDER_ID =
593     "com.sun.enterprise.admin.wsmgmt.repository.impl.AppServRepositoryProvider";
594 }
595
Popular Tags