001: /*
002: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
003: *
004: * Copyright 1997-2008 Sun Microsystems, Inc. All rights reserved.
005: *
006: * The contents of this file are subject to the terms of either the GNU
007: * General Public License Version 2 only ("GPL") or the Common Development
008: * and Distribution License("CDDL") (collectively, the "License"). You
009: * may not use this file except in compliance with the License. You can obtain
010: * a copy of the License at https://glassfish.dev.java.net/public/CDDL+GPL.html
011: * or glassfish/bootstrap/legal/LICENSE.txt. See the License for the specific
012: * language governing permissions and limitations under the License.
013: *
014: * When distributing the software, include this License Header Notice in each
015: * file and include the License file at glassfish/bootstrap/legal/LICENSE.txt.
016: * Sun designates this particular file as subject to the "Classpath" exception
017: * as provided by Sun in the GPL Version 2 section of the License file that
018: * accompanied this code. If applicable, add the following below the License
019: * Header, with the fields enclosed by brackets [] replaced by your own
020: * identifying information: "Portions Copyrighted [year]
021: * [name of copyright owner]"
022: *
023: * Contributor(s):
024: *
025: * If you wish your version of this file to be governed by only the CDDL or
026: * only the GPL Version 2, indicate your decision by adding "[Contributor]
027: * elects to include this software in this distribution under the [CDDL or GPL
028: * Version 2] license." If you don't indicate a single choice of license, a
029: * recipient has the option to distribute your version of this file under
030: * either the CDDL, the GPL Version 2 or to extend the choice of license to
031: * its licensees as provided above. However, if you add GPL Version 2 code
032: * and therefore, elected the GPL Version 2 license, then the option applies
033: * only if the new code is made subject to such option by the copyright
034: * holder.
035: */
036: package com.sun.jbi.jsf.bean;
037:
038: import com.sun.jbi.jsf.util.JBILogger;
039: import com.sun.jbi.jsf.util.JSFUtils;
040: import com.sun.webui.jsf.component.PropertySheet;
041: import java.util.Properties;
042:
043: /**
044: * A JavaServer Faces managed bean that supports: installation-time component
045: * configuration, runtime component configuration, and runtime component
046: * application configuration. <p>
047: *
048: * For installation-time component configuration this bean uses the jbi.xml
049: * from a not-yet-installed component archive. If this jbi.xml uses a
050: * schema-valid configuration extension element and property subelements,
051: * those properties that are to be displayed during installation are used to
052: * determine how to display editable installation configuration properties,
053: * which, when accepted or altered, this bean then passes to the installer for
054: * use when setting the component's installation extension configuration
055: * MBean's corresponding attributes. </p> <p>
056: *
057: * For runtime component configuration, this bean uses the common client APIs
058: * to determine if the component supports configuration and to get the schema
059: * and extension elements. If the component supports configuration and
060: * provides extension elements, those properties that are to be displayed
061: * during runtime configuration are used to determine how to display editiable
062: * runtime configuration properties, which when altered and saved, this bean
063: * the passes to the common client for use when setting the component's
064: * runtime configuration extension MBean's corresponding attributes.
065: *
066: * @author Sun Microsystems Inc.
067: */
068: public class CompConfigBean {
069:
070: /**
071: * Gets the CompInstallationConfigPS attribute of the CompConfigBean
072: * object
073: *
074: * @return The CompInstallationConfigPS value
075: */
076: public PropertySheet getCompInstallationConfigPS() {
077: if (JBILogger.isLoggableFiner()) {
078: JBILogger.logFiner(CN, MN_GET_COMP_INSTALLATION_CONFIG_PS,
079: "mCompInstallationConfigPS="
080: + mCompInstallationConfigPS);
081: }
082: return mCompInstallationConfigPS;
083: }
084:
085: /**
086: * Gets the properties from the component installation
087: * configuration property sheet, if any.
088: * @return a possibly empty set of properties
089: */
090: public Properties getCompInstallationConfigProperties() {
091: Properties result = new Properties();
092: JSFUtils.decodeCompInstallationConfigProperties(
093: mCompInstallationConfigPS, result);
094: return result;
095: }
096:
097: /**
098: * Gets the CompRuntimeAppConfigPS attribute of the CompConfigBean object
099: *
100: * @return The CompRuntimeAppConfigPS value
101: */
102: public PropertySheet getCompRuntimeAppConfigPS() {
103: if (JBILogger.isLoggableFiner()) {
104: JBILogger.logFiner(CN, MN_GET_COMP_RUNTIME_APP_CONFIG_PS,
105: "mCompRuntimeAppConfigPS="
106: + mCompRuntimeAppConfigPS);
107: }
108: return mCompRuntimeAppConfigPS;
109: }
110:
111: /**
112: * Gets the CompRuntimeAppVarsPS attribute of the CompConfigBean object
113: *
114: * @return The CompRuntimeAppVarsPS value
115: */
116: public PropertySheet getCompRuntimeAppVarsPS() {
117: if (JBILogger.isLoggableFiner()) {
118: JBILogger.logFiner(CN, MN_GET_COMP_RUNTIME_APP_VARS_PS,
119: "mCompRuntimeAppVarsPS=" + mCompRuntimeAppVarsPS);
120: }
121: return mCompRuntimeAppVarsPS;
122: }
123:
124: /**
125: * Gets the CompRuntimeCompConfigPS attribute of the CompConfigBean object
126: *
127: * @return The CompRuntimeCompConfigPS value
128: */
129: public PropertySheet getCompRuntimeCompConfigPS() {
130: if (null == mCompInstallationConfigPS) {
131: mCompInstallationConfigPS = JSFUtils
132: .getCompRuntimeCompConfigPS("unk inst",
133: "unk compName", "unk compType",
134: "not supported");
135: }
136: if (JBILogger.isLoggableFiner()) {
137: JBILogger.logFiner(CN, MN_GET_COMP_RUNTIME_COMP_CONFIG_PS,
138: "mCompRuntimeCompConfigPS="
139: + mCompRuntimeCompConfigPS);
140: }
141: return mCompRuntimeCompConfigPS;
142: }
143:
144: /**
145: * Gets the IsCompInstallationConfigSupported attribute of the
146: * CompConfigBean object
147: *
148: * @return The IsCompInstallationConfigSupported value
149: */
150: public boolean getIsCompInstallationConfigSupported() {
151: if (JBILogger.isLoggableFiner()) {
152: JBILogger.logFiner(CN,
153: MN_GET_IS_COMP_INSTALLATION_CONFIG_SUPPORTED,
154: "mIsCompInstallationConfigSupported="
155: + mIsCompInstallationConfigSupported);
156: }
157: return mIsCompInstallationConfigSupported;
158: }
159:
160: /**
161: * Gets the IsCompRuntimeAppConfigSupported attribute of the
162: * CompConfigBean object
163: *
164: * @return The IsCompRuntimeAppConfigSupported value
165: */
166: public boolean getIsCompRuntimeAppConfigSupported() {
167: if (JBILogger.isLoggableFiner()) {
168: JBILogger.logFiner(CN,
169: MN_GET_IS_COMP_RUNTIME_APP_CONFIG_SUPPORTED,
170: "mIsCompRuntimeAppConfigSupported="
171: + mIsCompRuntimeAppConfigSupported);
172: }
173: return mIsCompRuntimeAppConfigSupported;
174: }
175:
176: /**
177: * Gets the IsCompRuntimeAppVarsSupported attribute of the CompConfigBean
178: * object
179: *
180: * @return The IsCompRuntimeAppVarsSupported value
181: */
182: public boolean getIsCompRuntimeAppVarsSupported() {
183: if (JBILogger.isLoggableFiner()) {
184: JBILogger.logFiner(CN,
185: MN_GET_IS_COMP_RUNTIME_APP_VARS_SUPPORTED,
186: "mIsCompRuntimeAppVarsSupported="
187: + mIsCompRuntimeAppVarsSupported);
188: }
189: return mIsCompRuntimeAppVarsSupported;
190: }
191:
192: /**
193: * Gets the IsCompRuntimeCompConfigSupported attribute of the
194: * CompConfigBean object
195: *
196: * @return The IsCompRuntimeCompConfigSupported value
197: */
198: public boolean getIsCompRuntimeCompConfigSupported() {
199: if (JBILogger.isLoggableFiner()) {
200: JBILogger.logFiner(CN,
201: MN_GET_IS_COMP_RUNTIME_COMP_CONFIG_SUPPORTED,
202: "mIsCompRuntimeCompConfigSupported="
203: + mIsCompRuntimeCompConfigSupported);
204: }
205: return mIsCompRuntimeCompConfigSupported;
206: }
207:
208: /**
209: * Sets the CompInstallationConfigPS attribute of the CompConfigBean
210: * object
211: *
212: * @param anInstallationConfigPS The new CompInstallationConfigPS value
213: */
214: public void setCompInstallationConfigPS(
215: PropertySheet anInstallationConfigPS) {
216: mCompInstallationConfigPS = anInstallationConfigPS;
217: if (JBILogger.isLoggableFiner()) {
218: JBILogger.logFiner(CN, MN_SET_COMP_INSTALLATION_CONFIG_PS,
219: "mCompInstallationConfigPS="
220: + mCompInstallationConfigPS);
221: }
222: }
223:
224: /**
225: * required by JavaServer Faces introspection, but never invoked
226: * @param anIgnoredArgument which are ignored if this method was invoked
227: */
228: public void setCompInstallationConfigProperties(
229: Properties anIgnoredArgument) {
230: // required, but not used
231: }
232:
233: /**
234: * Sets the CompRuntimeAppConfigPS attribute of the CompConfigBean object
235: *
236: * @param aCompRuntimeAppConfigPS The new CompRuntimeAppConfigPS value
237: */
238: public void setCompRuntimeAppConfigPS(
239: PropertySheet aCompRuntimeAppConfigPS) {
240: mCompRuntimeAppConfigPS = aCompRuntimeAppConfigPS;
241: if (JBILogger.isLoggableFiner()) {
242: JBILogger.logFiner(CN, MN_SET_COMP_RUNTIME_APP_CONFIG_PS,
243: "mCompRuntimeAppConfigPS="
244: + mCompRuntimeAppConfigPS);
245: }
246: }
247:
248: /**
249: * Sets the CompRuntimeAppVarsPS attribute of the CompConfigBean object
250: *
251: * @param aCompRuntimeAppVarsPS The new CompRuntimeAppVarsPS value
252: */
253: public void setCompRuntimeAppVarsPS(
254: PropertySheet aCompRuntimeAppVarsPS) {
255: mCompRuntimeAppVarsPS = aCompRuntimeAppVarsPS;
256: if (JBILogger.isLoggableFiner()) {
257: JBILogger.logFiner(CN, MN_SET_COMP_RUNTIME_APP_VARS_PS,
258: "mCompRuntimeAppVarsPS=" + mCompRuntimeAppVarsPS);
259: }
260: }
261:
262: /**
263: * Sets the CompRuntimeCompConfigPS attribute of the CompConfigBean object
264: *
265: * @param aCompRuntimeCompConfigPS The new CompRuntimeCompConfigPS value
266: */
267: public void setCompRuntimeCompConfigPS(
268: PropertySheet aCompRuntimeCompConfigPS) {
269: mCompRuntimeCompConfigPS = aCompRuntimeCompConfigPS;
270: if (JBILogger.isLoggableFiner()) {
271: JBILogger.logFiner(CN, MN_SET_COMP_RUNTIME_COMP_CONFIG_PS,
272: "mIsCompRuntimeAppConfigSupported="
273: + mIsCompRuntimeAppConfigSupported);
274: }
275: }
276:
277: /**
278: * Sets the IsCompInstallationConfigSupported attribute of the
279: * CompConfigBean object
280: *
281: * @param isCompInstallationConfigSupported The new
282: * IsCompInstallationConfigSupported value
283: */
284: public void setIsCompInstallationConfigSupported(
285: boolean isCompInstallationConfigSupported) {
286: mIsCompInstallationConfigSupported = isCompInstallationConfigSupported;
287: if (JBILogger.isLoggableFiner()) {
288: JBILogger.logFiner(CN,
289: MN_SET_IS_COMP_INSTALLATION_CONFIG_SUPPORTED,
290: "mIsCompInstallationConfigSupported="
291: + mIsCompInstallationConfigSupported);
292: }
293: }
294:
295: /**
296: * Sets the IsCompRuntimeAppConfigSupported attribute of the
297: * CompConfigBean object
298: *
299: * @param isCompRuntimeAppConfigSupported The new
300: * IsCompRuntimeAppConfigSupported value
301: */
302: public void setIsCompRuntimeAppConfigSupported(
303: boolean isCompRuntimeAppConfigSupported) {
304: mIsCompRuntimeAppConfigSupported = isCompRuntimeAppConfigSupported;
305: if (JBILogger.isLoggableFiner()) {
306: JBILogger.logFiner(CN,
307: MN_SET_IS_COMP_RUNTIME_APP_CONFIG_SUPPORTED,
308: "mIsCompRuntimeAppConfigSupported="
309: + mIsCompRuntimeAppConfigSupported);
310: }
311: }
312:
313: /**
314: * Sets the IsCompRuntimeAppVarsSupported attribute of the CompConfigBean
315: * object
316: *
317: * @param isCompRuntimeAppVarsSupported The new
318: * IsCompRuntimeAppVarsSupported value
319: */
320: public void setIsCompRuntimeAppVarsSupported(
321: boolean isCompRuntimeAppVarsSupported) {
322: mIsCompRuntimeAppVarsSupported = isCompRuntimeAppVarsSupported;
323: if (JBILogger.isLoggableFiner()) {
324: JBILogger.logFiner(CN,
325: MN_SET_IS_COMP_RUNTIME_APP_VARS_SUPPORTED,
326: "mIsCompRuntimeAppVarsSupported="
327: + mIsCompRuntimeAppVarsSupported);
328: }
329: }
330:
331: /**
332: * Sets the IsCompRuntimeCompConfigSupported attribute of the
333: * CompConfigBean object
334: *
335: * @param isCompRuntimeCompConfigSupported The new
336: * IsCompRuntimeCompConfigSupported value
337: */
338: public void setIsCompRuntimeCompConfigSupported(
339: boolean isCompRuntimeCompConfigSupported) {
340: mIsCompRuntimeCompConfigSupported = isCompRuntimeCompConfigSupported;
341: if (JBILogger.isLoggableFiner()) {
342: JBILogger.logFiner(CN,
343: MN_SET_IS_COMP_RUNTIME_COMP_CONFIG_SUPPORTED,
344: "mIsCompRuntimeCompConfigSupported="
345: + mIsCompRuntimeCompConfigSupported);
346: }
347: }
348:
349: private static final String CN = CompConfigBean.class.getName();
350: private static final String MN_GET_COMP_INSTALLATION_CONFIG_PS = "getCompInstallationConfigPS";
351: private static final String MN_GET_COMP_RUNTIME_APP_CONFIG_PS = "getCompRuntimeAppConfigPS";
352: private static final String MN_GET_COMP_RUNTIME_APP_VARS_PS = "getCompRuntimeAppVarsPS";
353: private static final String MN_GET_COMP_RUNTIME_COMP_CONFIG_PS = "getCompRuntimeCompConfigPS";
354: private static final String MN_GET_IS_COMP_INSTALLATION_CONFIG_SUPPORTED = "getIsCompInstallationConfigSupported";
355: private static final String MN_GET_IS_COMP_RUNTIME_APP_CONFIG_SUPPORTED = "getIsCompRuntimeAppConfigSupported";
356: private static final String MN_GET_IS_COMP_RUNTIME_APP_VARS_SUPPORTED = "getIsCompRuntimeAppVarsSupported";
357: private static final String MN_GET_IS_COMP_RUNTIME_COMP_CONFIG_SUPPORTED = "getIsCompRuntimeCompConfigSupported";
358: private static final String MN_SET_COMP_INSTALLATION_CONFIG_PS = "setCompInstallationConfigPS";
359: private static final String MN_SET_COMP_RUNTIME_APP_CONFIG_PS = "setCompRuntimeAppConfigPS";
360: private static final String MN_SET_COMP_RUNTIME_APP_VARS_PS = "setCompRuntimeAppVarsPS";
361: private static final String MN_SET_COMP_RUNTIME_COMP_CONFIG_PS = "setCompRuntimeCompConfigPS";
362: private static final String MN_SET_IS_COMP_INSTALLATION_CONFIG_SUPPORTED = "setIsCompInstallationConfigSupported";
363: private static final String MN_SET_IS_COMP_RUNTIME_APP_CONFIG_SUPPORTED = "setIsCompRuntimeAppConfigSupported";
364: private static final String MN_SET_IS_COMP_RUNTIME_APP_VARS_SUPPORTED = "setIsCompRuntimeAppVarsSupported";
365: private static final String MN_SET_IS_COMP_RUNTIME_COMP_CONFIG_SUPPORTED = "setIsCompRuntimeCompConfigSupported";
366:
367: /**
368: */
369: private PropertySheet mCompInstallationConfigPS;
370:
371: /**
372: */
373: private PropertySheet mCompRuntimeAppConfigPS;
374:
375: /**
376: */
377: private PropertySheet mCompRuntimeAppVarsPS;
378:
379: /**
380: */
381: private PropertySheet mCompRuntimeCompConfigPS;
382:
383: /**
384: */
385: private boolean mIsCompInstallationConfigSupported;
386:
387: /**
388: */
389: private boolean mIsCompRuntimeAppConfigSupported;
390:
391: /**
392: */
393: private boolean mIsCompRuntimeAppVarsSupported;
394:
395: /**
396: */
397: private boolean mIsCompRuntimeCompConfigSupported;
398:
399: }
|