001: /*
002: * BEGIN_HEADER - DO NOT EDIT
003: *
004: * The contents of this file are subject to the terms
005: * of the Common Development and Distribution License
006: * (the "License"). You may not use this file except
007: * in compliance with the License.
008: *
009: * You can obtain a copy of the license at
010: * https://open-esb.dev.java.net/public/CDDLv1.0.html.
011: * See the License for the specific language governing
012: * permissions and limitations under the License.
013: *
014: * When distributing Covered Code, include this CDDL
015: * HEADER in each file and include the License file at
016: * https://open-esb.dev.java.net/public/CDDLv1.0.html.
017: * If applicable add the following below this CDDL HEADER,
018: * with the fields enclosed by brackets "[]" replaced with
019: * your own identifying information: Portions Copyright
020: * [year] [name of copyright owner]
021: */
022:
023: /*
024: * @(#)GenericQuery.java
025: * Copyright 2004-2007 Sun Microsystems, Inc. All Rights Reserved.
026: *
027: * END_HEADER - DO NOT EDIT
028: */
029: /**
030: * GenericQuery.java
031: *
032: * SUN PROPRIETARY/CONFIDENTIAL.
033: * This software is the proprietary information of Sun Microsystems, Inc.
034: * Use is subject to license terms.
035: *
036: * Created on August 23, 2006, 5:17 PM
037: */package com.sun.jbi.management.registry;
038:
039: import java.math.BigInteger;
040: import java.util.List;
041: import com.sun.jbi.ComponentType;
042: import com.sun.jbi.management.ConfigurationCategory;
043: import com.sun.jbi.management.descriptor.ComponentDescriptor;
044: import com.sun.jbi.management.descriptor.Jbi;
045:
046: /**
047: * This interface encapsulates queries which are common to
048: * all targets ( domain / server / cluster ).
049: *
050: * @author Sun Microsystems, Inc.
051: */
052: public interface GenericQuery {
053:
054: /**
055: * @param componentName - Component name
056: * @return a List<String> of all servers installing a component.
057: * The List<String> excludes all non-clustered servers.
058: * @throws RegistryException if a read lock cannot be acquired to access the
059: * in-memory Registry.
060: *
061: */
062: List<String> getServersInstallingComponent(String componentName)
063: throws RegistryException;
064:
065: /**
066: * @param sharedLibraryName - Shared Library name
067: * @return a List<String> of all servers installing a shared library.
068: * The List<String> excludes all non-clustered servers.
069: * @throws RegistryException if a read lock cannot be acquired to access the
070: * in-memory Registry.
071: *
072: */
073: List<String> getServersInstallingSharedLibrary(
074: String sharedLibraryName) throws RegistryException;
075:
076: /**
077: * @param serviceAssemblyName - Service Assembly name
078: * @return a List<String> of all servers deploying a service assembly.
079: * The List<String> excludes all non-clustered servers.
080: * @throws RegistryException if a read lock cannot be acquired to access the
081: * in-memory Registry.
082: *
083: */
084: List<String> getServersDeployingServiceAssembly(
085: String serviceAssemblyName) throws RegistryException;
086:
087: /**
088: * @param componentName - Component name
089: * @return a List<String> of all clusters installing a component.
090: * @throws RegistryException if a read lock cannot be acquired to access the
091: * in-memory Registry.
092: *
093: */
094: List<String> getClustersInstallingComponent(String componentName)
095: throws RegistryException;
096:
097: /**
098: * @param sharedLibraryName - Shared Library name
099: * @return a List<String> of all clusters installing a shared library.
100: * @throws RegistryException if a read lock cannot be acquired to access the
101: * in-memory Registry.
102: *
103: */
104: List<String> getClustersInstallingSharedLibrary(
105: String sharedLibraryName) throws RegistryException;
106:
107: /**
108: * @param serviceAssemblyName - Service Assembly name
109: * @return a List<String> of all clusters deploying a service assembly.
110: * The List<String> excludes all non-clustered servers.
111: * @throws RegistryException if a read lock cannot be acquired to access the
112: * in-memory Registry.
113: *
114: */
115: List<String> getClustersDeployingServiceAssembly(
116: String serviceAssemblyName) throws RegistryException;
117:
118: /**
119: * @param componentName - component name
120: * @return the Installation descriptor for the component.
121: * @throws RegistryException if a read lock cannot be acquired to access the
122: * in-memory Registry.
123: */
124: String getComponentInstallationDescriptor(String componentName)
125: throws RegistryException;
126:
127: /**
128: * @param componentName - component name
129: * @return wrapper for the Installation descriptor for the component.
130: * @throws RegistryException if a read lock cannot be acquired to access the
131: * in-memory Registry.
132: */
133: ComponentDescriptor getComponentDescriptor(String componentName)
134: throws RegistryException;
135:
136: /**
137: * @param sharedLibraryName - shared library name
138: * @return the Installation descriptor for the shared library.
139: * @throws RegistryException if a read lock cannot be acquired to access the
140: * in-memory Registry.
141: */
142: String getSharedLibraryInstallationDescriptor(
143: String sharedLibraryName) throws RegistryException;
144:
145: /**
146: * @param serviceAssemblyName - service assembly name
147: * @return the Installation descriptor for the component.
148: * @throws RegistryException if a read lock cannot be acquired to access the
149: * in-memory Registry.
150: */
151: String getServiceAssemblyDeploymentDescriptor(
152: String serviceAssemblyName) throws RegistryException;
153:
154: /**
155: * @param serviceAssemblyName - service assembly name
156: * @param serviceUnitName - service unit name
157: * @return the Installation descriptor for the service unit.
158: * @throws RegistryException if a read lock cannot be acquired to access the
159: * in-memory Registry.
160: */
161: String getServiceUnitDeploymentDescriptor(
162: String serviceAssemblyName, String serviceUnitName)
163: throws RegistryException;
164:
165: /**
166: * @param serviceAssemblyName - service assembly name
167: * @return the filename for the associated archive
168: * @throws RegistryException if a problem exists.
169: */
170: String getServiceAssemblyArchive(String serviceAssemblyName)
171: throws RegistryException;
172:
173: /**
174: * @param componentName - component name
175: * @return the filename for the associated archive
176: * @throws RegistryException if a problem exists.
177: */
178: String getComponentArchive(String componentName)
179: throws RegistryException;
180:
181: /**
182: * @param sharedLibraryName - sharedLibrary name
183: * @return the filename for the associated archive
184: * @throws RegistryException if a problem exists.
185: */
186: String getSharedLibraryArchive(String sharedLibraryName)
187: throws RegistryException;
188:
189: /**
190: * @return true if a component is installed on one or more servers / clusters
191: * @throws RegistryException if a read lock cannot be acquired to access the
192: * in-memory Registry.
193: */
194: boolean isComponentInstalled(String componentName)
195: throws RegistryException;
196:
197: /**
198: * @return true if a shared library is installed on one or more servers / clusters
199: * @throws RegistryException if a read lock cannot be acquired to access the
200: * in-memory Registry.
201: */
202: boolean isSharedLibraryInstalled(String sharedLibraryName)
203: throws RegistryException;
204:
205: /**
206: * @return true if a service assembly is deployed on one or more servers / clusters
207: * @throws RegistryException if a read lock cannot be acquired to access the
208: * in-memory Registry.
209: */
210: boolean isServiceAssemblyDeployed(String serviceAssemblyName)
211: throws RegistryException;
212:
213: ComponentType getComponentType(String componentName)
214: throws RegistryException;
215:
216: /**
217: * @return a list of Servers from the registry
218: */
219: List<String> getServers() throws RegistryException;
220:
221: /**
222: * @return a list of Clusters from the registry
223: */
224: List<String> getClusters() throws RegistryException;
225:
226: /**
227: * @return true if the Shared Library is registered in the domain.
228: */
229: boolean isSharedLibraryRegistered(String sharedLibraryName)
230: throws RegistryException;
231:
232: /**
233: * @return true if the Service Assembly is registered in the domain.
234: */
235: boolean isServiceAssemblyRegistered(String serviceAssemblyName)
236: throws RegistryException;
237:
238: /**
239: * @return true if the component is registered in the domain.
240: */
241: boolean isComponentRegistered(String componentName)
242: throws RegistryException;
243:
244: /**
245: * @return a List of Service Assemblies registered in the domain.
246: */
247: List<String> getRegisteredServiceAssemblies()
248: throws RegistryException;
249:
250: /**
251: * @return a List of Shared Libraries registered in the domain.
252: */
253: List<String> getRegisteredSharedLibraries()
254: throws RegistryException;
255:
256: /**
257: * @return a List of Components registered in the domain.
258: */
259: List<String> getRegisteredComponents() throws RegistryException;
260:
261: /**
262: * This method is used to find out if this is a system
263: * component.
264: * This method returns the value of system-install attribute
265: * for this component from the registry
266: * A component that has system-install set to true will have
267: * its install root under AS_INSTALL/jbi and it should not be
268: * deleted on unload of the component's uninstaller.
269: * @param componentName the name of the component
270: * @return boolean true if system-install is true, false otherwise
271: *
272: */
273: boolean isSystemComponent(String componentName)
274: throws RegistryException;
275:
276: /**
277: * This method is used to find out if this is a system
278: * shared library
279: * This method returns the value of system-install attribute
280: * for this shared library from the registry
281: * A shared library that has system-install set to true will have
282: * its install root under AS_INSTALL/jbi and it should not be
283: * deleted on uninstall
284: * @param sharedLibraryName the name of the shared library
285: * @return boolean true if system-install is true, false otherwise
286: *
287: */
288: boolean isSystemSharedLibrary(String sharedLibraryName)
289: throws RegistryException;
290:
291: /**
292: * Get the file name for the domain component.
293: *
294: * @param componentName - component name
295: */
296: String getComponentFileName(String componentName)
297: throws RegistryException;
298:
299: /**
300: * Get the file name for the domain shared library.
301: *
302: * @param slName - shared library name
303: */
304: String getSharedLibraryFileName(String slName)
305: throws RegistryException;
306:
307: /**
308: * Get the file name for the domain service assembly.
309: *
310: * @param saName - service assembly name
311: */
312: String getServiceAssemblyFileName(String saName)
313: throws RegistryException;
314:
315: /**
316: * Get the timestamp for the domain component.
317: *
318: * @param componentName - component name
319: */
320: long getComponentTimestamp(String componentName)
321: throws RegistryException;
322:
323: /**
324: * Get the timestamp for the domain shared library.
325: *
326: * @param slName - shared library name
327: */
328: long getSharedLibraryTimestamp(String slName)
329: throws RegistryException;
330:
331: /**
332: * Get the timestamp for the domain service assembly.
333: *
334: * @param saName - service assembly name
335: */
336: long getServiceAssemblyTimestamp(String saName)
337: throws RegistryException;
338:
339: /**
340: * This method is used to get the value of the attribute upgrade-number from the
341: * domain level entry for the component in the registry
342: * @param componentName the componentName
343: * @return BigInteger the upgrade number
344: * @throws RegistryException if the upgrade number could not be retrieved
345: */
346: public BigInteger getComponentUpgradeNumber(String componentName)
347: throws RegistryException;
348:
349: /*--------------------------------------------------------------------------------*\
350: * Get configuration attribute values *
351: \*--------------------------------------------------------------------------------*/
352:
353: /**
354: * Get the value of a configuration attribute belonging to the
355: * specified category, for the runtime target.
356: *
357: * @param type - configuration category
358: * @param name - identification for the attribute
359: * @exception RegistryException on errors in getting the attribute value
360: * @return the String representation of the attributes value
361: */
362: String getAttribute(ConfigurationCategory type, String name)
363: throws RegistryException;
364:
365: /**
366: * Get the value of a configuration attribute belonging to the
367: * specified category, for the specified target.
368: *
369: * @param targetName - target instance/cluster name.
370: * @param type - configuration category
371: * @param name - identification for the attribute
372: * @exception RegistryException on errors in getting the attribute value
373: * @return the String representation of the attributes value
374: */
375: String getAttribute(String targetName, ConfigurationCategory type,
376: String name) throws RegistryException;
377:
378: /**
379: * Determine if a configuration attribute is overriden by a target.
380: *
381: * @param targetName - target instance/cluster name.
382: * @param type - configuration category
383: * @param name - identification for the attribute
384: * @return true if the attribute is overriden by a target
385: */
386: public boolean isAttributeOverriden(String targetName,
387: ConfigurationCategory type, String name);
388:
389: /**
390: * Determine if the domain configuration is present in the registry
391: *
392: * @return true if the domain-config is defined in the registry
393: */
394: boolean isGlobalConfigurationDefined();
395: }
|