0001: /*
0002: * BEGIN_HEADER - DO NOT EDIT
0003: *
0004: * The contents of this file are subject to the terms
0005: * of the Common Development and Distribution License
0006: * (the "License"). You may not use this file except
0007: * in compliance with the License.
0008: *
0009: * You can obtain a copy of the license at
0010: * https://open-esb.dev.java.net/public/CDDLv1.0.html.
0011: * See the License for the specific language governing
0012: * permissions and limitations under the License.
0013: *
0014: * When distributing Covered Code, include this CDDL
0015: * HEADER in each file and include the License file at
0016: * https://open-esb.dev.java.net/public/CDDLv1.0.html.
0017: * If applicable add the following below this CDDL HEADER,
0018: * with the fields enclosed by brackets "[]" replaced with
0019: * your own identifying information: Portions Copyright
0020: * [year] [name of copyright owner]
0021: */
0022:
0023: /*
0024: * @(#)JBIAdminCommands.java
0025: * Copyright 2004-2007 Sun Microsystems, Inc. All Rights Reserved.
0026: *
0027: * END_HEADER - DO NOT EDIT
0028: */
0029: package com.sun.jbi.ui.common;
0030:
0031: import java.util.Map;
0032: import java.util.Properties;
0033: import java.util.logging.Level;
0034:
0035: import javax.management.ObjectName;
0036: import javax.management.openmbean.CompositeData;
0037: import javax.management.openmbean.TabularData;
0038:
0039: /**
0040: * @(#)JBIAdminCommands.java - ver 2.0 - 08/22/2006
0041: *
0042: * This interface defines the methods corresponding to jbi administration tool
0043: * commands and helper methods using which ant, cli, web admin tools and other
0044: * management clients execute remote jbi administration commands on the jbi
0045: * runtime.
0046: *
0047: * Client side implementations of this interface invoke the server side
0048: * implemenation through JMX to execute commands on the server.
0049: *
0050: * The Server side implements this interface as an MBean so that management
0051: * clients could invoke this interface implementation through JMX.
0052: *
0053: * @author graj
0054: */
0055: public interface JBIAdminCommands {
0056:
0057: public static final String DOMAIN_TARGET_KEY = "domain";
0058:
0059: public static final String SERVER_TARGET_KEY = "server";
0060:
0061: public static final String CUSTOM_CONFIGURATION_NAME_KEY = "Configuration";
0062:
0063: public static final String CUSTOM_LOGGER_NAME_KEY = "Logger";
0064:
0065: /**
0066: * installs component ( service engine, binding component)
0067: *
0068: * @param paramProps
0069: * Properties object contains name/value pair.
0070: * @param zipFilePath
0071: * archive file in a zip format
0072: * @param targetName
0073: * name of the target for this operation
0074: * @return Map of targetName and component name strings.
0075: * @throws JBIRemoteException
0076: * on error
0077: */
0078: public String installComponent(String zipFilePath,
0079: Properties paramProps, String targetName)
0080: throws JBIRemoteException;
0081:
0082: /**
0083: * installs component ( service engine, binding component)
0084: *
0085: * @param zipFilePath
0086: * archive file in a zip format
0087: * @param targetName
0088: * name of the target for this operation
0089: * @return Map of targetName and component name strings.
0090: * @throws JBIRemoteException
0091: * on error
0092: */
0093: public String installComponent(String zipFilePath, String targetName)
0094: throws JBIRemoteException;
0095:
0096: /**
0097: * uninstalls component ( service engine, binding component)
0098: *
0099: * @param componentName
0100: * name of the component
0101: * @param targetName
0102: * name of the target for this operation
0103: * @return Map of targetName and component name strings.
0104: * @throws JBIRemoteException
0105: * on error
0106: */
0107: public String uninstallComponent(String componentName,
0108: String targetName) throws JBIRemoteException;
0109:
0110: /**
0111: * installs shared library
0112: *
0113: * @param zipFilePath
0114: * archive file in a zip format
0115: * @param targetName
0116: * name of the target for this operation
0117: * @return Map of targetName and shared library name strings.
0118: * @throws JBIRemoteException
0119: * on error
0120: */
0121: public String installSharedLibrary(String zipFilePath,
0122: String targetName) throws JBIRemoteException;
0123:
0124: /**
0125: * uninstalls shared library
0126: *
0127: * @param sharedLibraryName
0128: * name of the shared library
0129: * @param targetName
0130: * name of the target for this operation
0131: * @return Map of targetName and shared library name strings.
0132: * @throws JBIRemoteException
0133: * on error
0134: */
0135: public String uninstallSharedLibrary(String sharedLibraryName,
0136: String targetName) throws JBIRemoteException;
0137:
0138: /**
0139: * starts component ( service engine, binding component)
0140: *
0141: * @param componentName
0142: * name of the component
0143: * @param targetName
0144: * name of the target for this operation
0145: * @return Map of targetName and component name strings.
0146: * @throws JBIRemoteException
0147: * on error
0148: */
0149: public String startComponent(String componentName, String targetName)
0150: throws JBIRemoteException;
0151:
0152: /**
0153: * stops component ( service engine, binding component)
0154: *
0155: * @param componentName
0156: * name of the component
0157: * @param targetName
0158: * name of the target for this operation
0159: * @return Map of targetName and component name strings.
0160: * @throws JBIRemoteException
0161: * on error
0162: */
0163: public String stopComponent(String componentName, String targetName)
0164: throws JBIRemoteException;
0165:
0166: /**
0167: * shuts down component ( service engine, binding component)
0168: *
0169: * @param componentName
0170: * name of the component
0171: * @param targetName
0172: * name of the target for this operation
0173: * @return Map of targetName and component name strings.
0174: * @throws JBIRemoteException
0175: * on error
0176: */
0177: public String shutdownComponent(String componentName,
0178: String targetName) throws JBIRemoteException;
0179:
0180: /**
0181: * shuts down component ( service engine, binding component)
0182: *
0183: * @param componentName
0184: * name of the component
0185: * @param force
0186: * true if component should be shutdown in any case, else false.
0187: * @param targetName
0188: * name of the target for this operation
0189: * @return Map of targetName and component name strings.
0190: * @throws JBIRemoteException
0191: * on error
0192: */
0193: public String shutdownComponent(String componentName,
0194: boolean force, String targetName) throws JBIRemoteException;
0195:
0196: /**
0197: * deploys service assembly
0198: *
0199: * @param zipFilePath
0200: * fie path
0201: * @param targetName
0202: * name of the target for this operation
0203: * @return Map of targetName and management message xml text strings.
0204: * @throws JBIRemoteException
0205: * on error
0206: */
0207: public String deployServiceAssembly(String zipFilePath,
0208: String targetName) throws JBIRemoteException;
0209:
0210: /**
0211: * undeploys service assembly
0212: *
0213: * @param serviceAssemblyName
0214: * name of the service assembly
0215: * @param targetName
0216: * name of the target for this operation
0217: * @return Map of targetName and result as a management message xml text
0218: * strings.
0219: * @throws JBIRemoteException
0220: * on error
0221: */
0222: public String undeployServiceAssembly(String serviceAssemblyName,
0223: String targetName) throws JBIRemoteException;
0224:
0225: /**
0226: * starts service assembly
0227: *
0228: * @param serviceAssemblyName
0229: * name of the service assembly
0230: * @param targetName
0231: * name of the target for this operation
0232: * @return Map of targetName and result as a management message xml text
0233: * strings.
0234: * @throws JBIRemoteException
0235: * on error
0236: */
0237: public String startServiceAssembly(String serviceAssemblyName,
0238: String targetName) throws JBIRemoteException;
0239:
0240: /**
0241: * stops service assembly
0242: *
0243: * @param serviceAssemblyName
0244: * name of the service assembly
0245: * @param targetName
0246: * name of the target for this operation
0247: * @return Map of targetName and result as a management message xml text
0248: * strings.
0249: * @throws JBIRemoteException
0250: * on error
0251: */
0252: public String stopServiceAssembly(String serviceAssemblyName,
0253: String targetName) throws JBIRemoteException;
0254:
0255: /**
0256: * shuts down service assembly
0257: *
0258: * @param serviceAssemblyName
0259: * name of the service assembly
0260: * @param targetName
0261: * name of the target for this operation
0262: * @return Map of targetName and result as a management message xml text
0263: * strings.
0264: * @throws JBIRemoteException
0265: * on error
0266: */
0267: public String shutdownServiceAssembly(String serviceAssemblyName,
0268: String targetName) throws JBIRemoteException;
0269:
0270: /**
0271: * shuts down service assembly
0272: *
0273: * @param serviceAssemblyName
0274: * name of the service assembly
0275: * @param forceShutdown
0276: * @param targetName
0277: * name of the target for this operation
0278: * @return Map of targetName and result as a management message xml text
0279: * strings.
0280: * @throws JBIRemoteException
0281: * on error
0282: */
0283: public String shutdownServiceAssembly(String serviceAssemblyName,
0284: boolean forceShutdown, String targetName)
0285: throws JBIRemoteException;
0286:
0287: /**
0288: * return component info xml text that has only service engine infos.
0289: *
0290: * @param targetName
0291: * name of the target for this operation
0292: * @return the component info xml text.
0293: * @throws JBIRemoteException
0294: * on error
0295: */
0296: public String listServiceEngines(String targetName)
0297: throws JBIRemoteException;
0298:
0299: /**
0300: * return component info xml text that has only service engine infos which
0301: * satisfies the options passed to the method.
0302: *
0303: * @param state
0304: * return all the service engines that are in the specified
0305: * state. valid states are JBIComponentInfo.STARTED, STOPPED,
0306: * INSTALLED or null for ANY state
0307: * @param sharedLibraryName
0308: * return all the service engines that have a dependency on the
0309: * specified shared library. null value to ignore this option.
0310: * @param serviceAssemblyName
0311: * return all the service engines that have the specified service
0312: * assembly deployed on them. null value to ignore this option.
0313: * @param targetName
0314: * name of the target for this operation
0315: * @return xml text contain the list of service engine component infos
0316: * @throws JBIRemoteException
0317: * if error or exception occurs.
0318: */
0319: public String listServiceEngines(String state,
0320: String sharedLibraryName, String serviceAssemblyName,
0321: String targetName) throws JBIRemoteException;
0322:
0323: /**
0324: * return component info xml text that has only binding component infos.
0325: *
0326: * @param targetName
0327: * name of the target for this operation
0328: * @return the component info xml text.
0329: * @throws JBIRemoteException
0330: * on error
0331: */
0332: public String listBindingComponents(String targetName)
0333: throws JBIRemoteException;
0334:
0335: /**
0336: * return component info xml text that has only binding component infos
0337: * which satisfies the options passed to the method.
0338: *
0339: * @param state
0340: * return all the binding components that are in the specified
0341: * state. valid states are JBIComponentInfo.STARTED, STOPPED,
0342: * INSTALLED or null for ANY state
0343: * @param sharedLibraryName
0344: * return all the binding components that have a dependency on
0345: * the specified shared library. null value to ignore this
0346: * option.
0347: * @param serviceAssemblyName
0348: * return all the binding components that have the specified
0349: * service assembly deployed on them. null value to ignore this
0350: * option.
0351: * @param targetName
0352: * name of the target for this operation
0353: * @return xml text contain the list of binding component infos
0354: * @throws JBIRemoteException
0355: * if error or exception occurs.
0356: */
0357: public String listBindingComponents(String state,
0358: String sharedLibraryName, String serviceAssemblyName,
0359: String targetName) throws JBIRemoteException;
0360:
0361: /**
0362: * returns a list of Binding Component and Service Engine infos in xml
0363: * format, that are dependent upon a specified Shared Library
0364: *
0365: * @param sharedLibraryName
0366: * the shared library name
0367: * @param targetName
0368: * name of the target for this operation
0369: * @return xml string containing the list of componentInfos
0370: * @throws JBIRemoteException
0371: * on error
0372: */
0373: public String listSharedLibraryDependents(String sharedLibraryName,
0374: String targetName) throws JBIRemoteException;
0375:
0376: /**
0377: * return component info xml text that has only shared library infos.
0378: *
0379: * @param targetName
0380: * name of the target for this operation
0381: * @return the component info xml text.
0382: * @throws JBIRemoteException
0383: * on error
0384: */
0385: public String listSharedLibraries(String targetName)
0386: throws JBIRemoteException;
0387:
0388: /**
0389: * returns the list of Shared Library infos in the in a xml format
0390: *
0391: * @param componentName
0392: * to return only the shared libraries that are this component
0393: * dependents. null for listing all the shared libraries in the
0394: * system.
0395: * @param targetName
0396: * name of the target for this operation
0397: * @return xml string contain the list of componentinfos for shared
0398: * libraries.
0399: * @throws JBIRemoteException
0400: * if error or exception occurs.
0401: */
0402: public String listSharedLibraries(String componentName,
0403: String targetName) throws JBIRemoteException;
0404:
0405: /**
0406: * returns a list of Service Assembly Infos in a xml format.
0407: *
0408: * @param targetName
0409: * name of the target for this operation
0410: * @return xml text containing the Service Assembly infos
0411: * @throws JBIRemoteException
0412: * on error
0413: */
0414: public String listServiceAssemblies(String targetName)
0415: throws JBIRemoteException;
0416:
0417: /**
0418: * returns the list of service asssembly infos in a xml format that have the
0419: * service unit deployed on the specified component.
0420: *
0421: * @param componentName
0422: * to list all the service assemblies that have some deployments
0423: * on this component.
0424: * @param targetName
0425: * name of the target for this operation
0426: * @return xml string contain the list of service assembly infos
0427: * @throws JBIRemoteException
0428: * if error or exception occurs.
0429: */
0430: public String listServiceAssemblies(String componentName,
0431: String targetName) throws JBIRemoteException;
0432:
0433: /**
0434: * returns the list of service asssembly infos in a xml format that have the
0435: * service unit deployed on the specified component.
0436: *
0437: * @param state
0438: * to return all the service assemblies that are in the specified
0439: * state. JBIServiceAssemblyInfo.STARTED, STOPPED, SHUTDOWN or
0440: * null for ANY state
0441: * @param componentName
0442: * to list all the service assemblies that have some deployments
0443: * on this component.
0444: * @param targetName
0445: * name of the target for this operation
0446: * @return xml string contain the list of service assembly infos
0447: * @throws JBIRemoteException
0448: * if error or exception occurs.
0449: */
0450: public String listServiceAssemblies(String state,
0451: String componentName, String targetName)
0452: throws JBIRemoteException;
0453:
0454: /**
0455: * return component info xml text for the specified service engine if
0456: * exists. If no service engine with that name exists, it returns the xml
0457: * with empty list.
0458: *
0459: * @param name
0460: * name of the service engine to lookup
0461: * @param state
0462: * return service engine that is in the specified state. valid
0463: * states are JBIComponentInfo.STARTED, STOPPED, INSTALLED or
0464: * null for ANY state
0465: * @param sharedLibraryName
0466: * return service engine that has a dependency on the specified
0467: * shared library. null value to ignore this option.
0468: * @param serviceAssemblyName
0469: * return the service engine that has the specified service
0470: * assembly deployed on it. null value to ignore this option.
0471: * @param targetName
0472: * name of the target for this operation
0473: * @return xml text contain the service engine component info that confirms
0474: * to the component info list xml grammer.
0475: * @throws JBIRemoteException
0476: * if error or exception occurs.
0477: */
0478: public String showServiceEngine(String name, String state,
0479: String sharedLibraryName, String serviceAssemblyName,
0480: String targetName) throws JBIRemoteException;
0481:
0482: /**
0483: * return component info xml text for the specified binding component if
0484: * exists. If no binding component with that name exists, it returns the xml
0485: * with empty list.
0486: *
0487: * @param name
0488: * name of the binding component to lookup
0489: * @param state
0490: * return the binding component that is in the specified state.
0491: * valid states are JBIComponentInfo.STARTED, STOPPED, INSTALLED
0492: * or null for ANY state
0493: * @param sharedLibraryName
0494: * return the binding component that has a dependency on the
0495: * specified shared library. null value to ignore this option.
0496: * @param serviceAssemblyName
0497: * return the binding component that has the specified service
0498: * assembly deployed on it. null value to ignore this option.
0499: * @param targetName
0500: * name of the target for this operation
0501: * @return xml text contain the binding component info that confirms to the
0502: * component info list xml grammer.
0503: * @throws JBIRemoteException
0504: * if error or exception occurs.
0505: */
0506: public String showBindingComponent(String name, String state,
0507: String sharedLibraryName, String serviceAssemblyName,
0508: String targetName) throws JBIRemoteException;
0509:
0510: /**
0511: * return component info xml text for the specified shared library if
0512: * exists. If no shared library with that name exists, it returns the xml
0513: * with empty list.
0514: *
0515: * @param name
0516: * name of the shared library to lookup
0517: * @param componentName
0518: * return the shared library that is this component dependents.
0519: * null to ignore this option.
0520: * @param targetName
0521: * name of the target for this operation
0522: * @return xml string contain shared library component info that confirms to
0523: * the component info list xml grammer.
0524: * @throws JBIRemoteException
0525: * if error or exception occurs.
0526: */
0527: public String showSharedLibrary(String name, String componentName,
0528: String targetName) throws JBIRemoteException;
0529:
0530: /**
0531: * return service assembly info xml text for the specified service assembly
0532: * if exists. If no service assembly with that name exists, it returns the
0533: * xml with empty list.
0534: *
0535: * @param name
0536: * name of the service assembly to lookup
0537: * @param state
0538: * return the service assembly that is in the specified state.
0539: * JBIServiceAssemblyInfo.STARTED, STOPPED, SHUTDOWN or null for
0540: * ANY state
0541: * @param componentName
0542: * return the service assembly that has service units on this
0543: * component.
0544: * @param targetName
0545: * name of the target for this operation
0546: * @return xml string contain service assembly info that confirms to the
0547: * service assembly list xml grammer.
0548: * @throws JBIRemoteException
0549: * if error or exception occurs.
0550: */
0551: public String showServiceAssembly(String name, String state,
0552: String componentName, String targetName)
0553: throws JBIRemoteException;
0554:
0555: /**
0556: * installs component ( service engine, binding component)
0557: *
0558: * @param paramProps
0559: * Properties object contains name/value pair.
0560: * @param zipFilePath
0561: * archive file in a zip format
0562: * @param targetName
0563: * name of the target for this operation
0564: * @return Map of targetName and component name strings.
0565: * @throws JBIRemoteException
0566: * on error
0567: */
0568: public Map<String /* targetName */, String /* targetResult */> installComponent(
0569: String zipFilePath, Properties paramProps,
0570: String[] targetNames) throws JBIRemoteException;
0571:
0572: /**
0573: * installs component ( service engine, binding component)
0574: *
0575: * @param zipFilePath
0576: * archive file in a zip format
0577: * @param targetName
0578: * name of the target for this operation
0579: * @return Map of targetName and component name strings.
0580: * @throws JBIRemoteException
0581: * on error
0582: */
0583: public Map<String /* targetName */, String /* targetResult */> installComponent(
0584: String zipFilePath, String[] targetNames)
0585: throws JBIRemoteException;
0586:
0587: /**
0588: * uninstalls component ( service engine, binding component)
0589: *
0590: * @param componentName
0591: * name of the component
0592: * @param targetName
0593: * name of the target for this operation
0594: * @return Map of targetName and component name strings.
0595: * @throws JBIRemoteException
0596: * on error
0597: */
0598: public Map<String /* targetName */, String /* targetResult */> uninstallComponent(
0599: String componentName, String[] targetNames)
0600: throws JBIRemoteException;
0601:
0602: /**
0603: * installs shared library
0604: *
0605: * @param zipFilePath
0606: * archive file in a zip format
0607: * @param targetName
0608: * name of the target for this operation
0609: * @return Map of targetName and shared library name strings.
0610: * @throws JBIRemoteException
0611: * on error
0612: */
0613: public Map<String /* targetName */, String /* targetResult */> installSharedLibrary(
0614: String zipFilePath, String[] targetNames)
0615: throws JBIRemoteException;
0616:
0617: /**
0618: * uninstalls shared library
0619: *
0620: * @param sharedLibraryName
0621: * name of the shared library
0622: * @param targetName
0623: * name of the target for this operation
0624: * @return Map of targetName and shared library name strings.
0625: * @throws JBIRemoteException
0626: * on error
0627: */
0628: public Map<String /* targetName */, String /* targetResult */> uninstallSharedLibrary(
0629: String sharedLibraryName, String[] targetNames)
0630: throws JBIRemoteException;
0631:
0632: /**
0633: * starts component ( service engine, binding component)
0634: *
0635: * @param componentName
0636: * name of the component
0637: * @param targetName
0638: * name of the target for this operation
0639: * @return Map of targetName and component name strings.
0640: * @throws JBIRemoteException
0641: * on error
0642: */
0643: public Map<String /* targetName */, String /* targetResult */> startComponent(
0644: String componentName, String[] targetNames)
0645: throws JBIRemoteException;
0646:
0647: /**
0648: * stops component ( service engine, binding component)
0649: *
0650: * @param componentName
0651: * name of the component
0652: * @param targetName
0653: * name of the target for this operation
0654: * @return Map of targetName and component name strings.
0655: * @throws JBIRemoteException
0656: * on error
0657: */
0658: public Map<String /* targetName */, String /* targetResult */> stopComponent(
0659: String componentName, String[] targetNames)
0660: throws JBIRemoteException;
0661:
0662: /**
0663: * shuts down component ( service engine, binding component)
0664: *
0665: * @param componentName
0666: * name of the component
0667: * @param targetName
0668: * name of the target for this operation
0669: * @return Map of targetName and component name strings.
0670: * @throws JBIRemoteException
0671: * on error
0672: */
0673: public Map<String /* targetName */, String /* targetResult */> shutdownComponent(
0674: String componentName, String[] targetNames)
0675: throws JBIRemoteException;
0676:
0677: /**
0678: * shuts down component ( service engine, binding component)
0679: *
0680: * @param componentName
0681: * name of the component
0682: * @param force
0683: * true if component should be shutdown in any case, else false.
0684: * @param targetName
0685: * name of the target for this operation
0686: * @return Map of targetName and component name strings.
0687: * @throws JBIRemoteException
0688: * on error
0689: */
0690: public Map<String /* targetName */, String /* targetResult */> shutdownComponent(
0691: String componentName, boolean force, String[] targetNames)
0692: throws JBIRemoteException;
0693:
0694: /**
0695: * deploys service assembly
0696: *
0697: * @param zipFilePath
0698: * fie path
0699: * @param targetName
0700: * name of the target for this operation
0701: * @return Map of targetName and management message xml text strings.
0702: * @throws JBIRemoteException
0703: * on error
0704: */
0705: public Map<String /* targetName */, String /* targetResult */> deployServiceAssembly(
0706: String zipFilePath, String[] targetNames)
0707: throws JBIRemoteException;
0708:
0709: /**
0710: * undeploys service assembly
0711: *
0712: * @param serviceAssemblyName
0713: * name of the service assembly
0714: * @param targetName
0715: * name of the target for this operation
0716: * @return Map of targetName and result as a management message xml text
0717: * strings.
0718: * @throws JBIRemoteException
0719: * on error
0720: */
0721: public Map<String /* targetName */, String /* targetResult */> undeployServiceAssembly(
0722: String serviceAssemblyName, String[] targetNames)
0723: throws JBIRemoteException;
0724:
0725: /**
0726: * starts service assembly
0727: *
0728: * @param serviceAssemblyName
0729: * name of the service assembly
0730: * @param targetName
0731: * name of the target for this operation
0732: * @return Map of targetName and result as a management message xml text
0733: * strings.
0734: * @throws JBIRemoteException
0735: * on error
0736: */
0737: public Map<String /* targetName */, String /* targetResult */> startServiceAssembly(
0738: String serviceAssemblyName, String[] targetNames)
0739: throws JBIRemoteException;
0740:
0741: /**
0742: * stops service assembly
0743: *
0744: * @param serviceAssemblyName
0745: * name of the service assembly
0746: * @param targetName
0747: * name of the target for this operation
0748: * @return Map of targetName and result as a management message xml text
0749: * strings.
0750: * @throws JBIRemoteException
0751: * on error
0752: */
0753: public Map<String /* targetName */, String /* targetResult */> stopServiceAssembly(
0754: String serviceAssemblyName, String[] targetNames)
0755: throws JBIRemoteException;
0756:
0757: /**
0758: * shuts down service assembly
0759: *
0760: * @param serviceAssemblyName
0761: * name of the service assembly
0762: * @param targetName
0763: * name of the target for this operation
0764: * @return Map of targetName and result as a management message xml text
0765: * strings.
0766: * @throws JBIRemoteException
0767: * on error
0768: */
0769: public Map<String /* targetName */, String /* targetResult */> shutdownServiceAssembly(
0770: String serviceAssemblyName, String[] targetNames)
0771: throws JBIRemoteException;
0772:
0773: /**
0774: * shuts down service assembly
0775: *
0776: * @param serviceAssemblyName
0777: * name of the service assembly
0778: * @param forceShutdown
0779: * @param targetName
0780: * name of the target for this operation
0781: * @return Map of targetName and result as a management message xml text
0782: * strings.
0783: * @throws JBIRemoteException
0784: * on error
0785: */
0786: public Map<String /* targetName */, String /* targetResult */> shutdownServiceAssembly(
0787: String serviceAssemblyName, boolean forceShutdown,
0788: String[] targetNames) throws JBIRemoteException;
0789:
0790: /**
0791: * return component info xml text that has only service engine infos.
0792: *
0793: * @param targetName
0794: * name of the target for this operation
0795: * @return the component info xml text.
0796: * @throws JBIRemoteException
0797: * on error
0798: */
0799: public Map<String /* targetName */, String /* targetResult */> listServiceEngines(
0800: String[] targetNames) throws JBIRemoteException;
0801:
0802: /**
0803: * return component info xml text that has only service engine infos which
0804: * satisfies the options passed to the method.
0805: *
0806: * @param state
0807: * return all the service engines that are in the specified
0808: * state. valid states are JBIComponentInfo.STARTED, STOPPED,
0809: * INSTALLED or null for ANY state
0810: * @param sharedLibraryName
0811: * return all the service engines that have a dependency on the
0812: * specified shared library. null value to ignore this option.
0813: * @param serviceAssemblyName
0814: * return all the service engines that have the specified service
0815: * assembly deployed on them. null value to ignore this option.
0816: * @param targetName
0817: * name of the target for this operation
0818: * @return xml text contain the list of service engine component infos
0819: * @throws JBIRemoteException
0820: * if error or exception occurs.
0821: */
0822: public Map<String /* targetName */, String /* targetResult */> listServiceEngines(
0823: String state, String sharedLibraryName,
0824: String serviceAssemblyName, String[] targetNames)
0825: throws JBIRemoteException;
0826:
0827: /**
0828: * return component info xml text that has only binding component infos.
0829: *
0830: * @param targetName
0831: * name of the target for this operation
0832: * @return the component info xml text.
0833: * @throws JBIRemoteException
0834: * on error
0835: */
0836: public Map<String /* targetName */, String /* targetResult */> listBindingComponents(
0837: String[] targetNames) throws JBIRemoteException;
0838:
0839: /**
0840: * return component info xml text that has only binding component infos
0841: * which satisfies the options passed to the method.
0842: *
0843: * @param state
0844: * return all the binding components that are in the specified
0845: * state. valid states are JBIComponentInfo.STARTED, STOPPED,
0846: * INSTALLED or null for ANY state
0847: * @param sharedLibraryName
0848: * return all the binding components that have a dependency on
0849: * the specified shared library. null value to ignore this
0850: * option.
0851: * @param serviceAssemblyName
0852: * return all the binding components that have the specified
0853: * service assembly deployed on them. null value to ignore this
0854: * option.
0855: * @param targetName
0856: * name of the target for this operation
0857: * @return xml text contain the list of binding component infos
0858: * @throws JBIRemoteException
0859: * if error or exception occurs.
0860: */
0861: public Map<String /* targetName */, String /* targetResult */> listBindingComponents(
0862: String state, String sharedLibraryName,
0863: String serviceAssemblyName, String[] targetNames)
0864: throws JBIRemoteException;
0865:
0866: /**
0867: * returns a list of Binding Component and Service Engine infos in xml
0868: * format, that are dependent upon a specified Shared Library
0869: *
0870: * @param sharedLibraryName
0871: * the shared library name
0872: * @param targetName
0873: * name of the target for this operation
0874: * @return xml string containing the list of componentInfos
0875: * @throws JBIRemoteException
0876: * on error
0877: */
0878: public Map<String /* targetName */, String /* targetResult */> listSharedLibraryDependents(
0879: String sharedLibraryName, String[] targetNames)
0880: throws JBIRemoteException;
0881:
0882: /**
0883: * return component info xml text that has only shared library infos.
0884: *
0885: * @param targetName
0886: * name of the target for this operation
0887: * @return the component info xml text.
0888: * @throws JBIRemoteException
0889: * on error
0890: */
0891: public Map<String /* targetName */, String /* targetResult */> listSharedLibraries(
0892: String[] targetNames) throws JBIRemoteException;
0893:
0894: /**
0895: * returns the list of Shared Library infos in the in a xml format
0896: *
0897: * @param componentName
0898: * to return only the shared libraries that are this component
0899: * dependents. null for listing all the shared libraries in the
0900: * system.
0901: * @param targetName
0902: * name of the target for this operation
0903: * @return xml string contain the list of componentinfos for shared
0904: * libraries.
0905: * @throws JBIRemoteException
0906: * if error or exception occurs.
0907: */
0908: public Map<String /* targetName */, String /* targetResult */> listSharedLibraries(
0909: String componentName, String[] targetNames)
0910: throws JBIRemoteException;
0911:
0912: /**
0913: * returns a list of Service Assembly Infos in a xml format.
0914: *
0915: * @param targetName
0916: * name of the target for this operation
0917: * @return xml text containing the Service Assembly infos
0918: * @throws JBIRemoteException
0919: * on error
0920: */
0921: public Map<String /* targetName */, String /* targetResult */> listServiceAssemblies(
0922: String[] targetNames) throws JBIRemoteException;
0923:
0924: /**
0925: * returns the list of service asssembly infos in a xml format that have the
0926: * service unit deployed on the specified component.
0927: *
0928: * @param componentName
0929: * to list all the service assemblies that have some deployments
0930: * on this component.
0931: * @param targetName
0932: * name of the target for this operation
0933: * @return xml string contain the list of service assembly infos
0934: * @throws JBIRemoteException
0935: * if error or exception occurs.
0936: */
0937: public Map<String /* targetName */, String /* targetResult */> listServiceAssemblies(
0938: String componentName, String[] targetNames)
0939: throws JBIRemoteException;
0940:
0941: /**
0942: * returns the list of service asssembly infos in a xml format that have the
0943: * service unit deployed on the specified component.
0944: *
0945: * @param state
0946: * to return all the service assemblies that are in the specified
0947: * state. JBIServiceAssemblyInfo.STARTED, STOPPED, SHUTDOWN or
0948: * null for ANY state
0949: * @param componentName
0950: * to list all the service assemblies that have some deployments
0951: * on this component.
0952: * @param targetName
0953: * name of the target for this operation
0954: * @return xml string contain the list of service assembly infos
0955: * @throws JBIRemoteException
0956: * if error or exception occurs.
0957: */
0958: public Map<String /* targetName */, String /* targetResult */> listServiceAssemblies(
0959: String state, String componentName, String[] targetNames)
0960: throws JBIRemoteException;
0961:
0962: /**
0963: * return component info xml text for the specified service engine if
0964: * exists. If no service engine with that name exists, it returns the xml
0965: * with empty list.
0966: *
0967: * @param name
0968: * name of the service engine to lookup
0969: * @param state
0970: * return service engine that is in the specified state. valid
0971: * states are JBIComponentInfo.STARTED, STOPPED, INSTALLED or
0972: * null for ANY state
0973: * @param sharedLibraryName
0974: * return service engine that has a dependency on the specified
0975: * shared library. null value to ignore this option.
0976: * @param serviceAssemblyName
0977: * return the service engine that has the specified service
0978: * assembly deployed on it. null value to ignore this option.
0979: * @param targetName
0980: * name of the target for this operation
0981: * @return xml text contain the service engine component info that confirms
0982: * to the component info list xml grammer.
0983: * @throws JBIRemoteException
0984: * if error or exception occurs.
0985: */
0986: public Map<String /* targetName */, String /* targetResult */> showServiceEngine(
0987: String name, String state, String sharedLibraryName,
0988: String serviceAssemblyName, String[] targetNames)
0989: throws JBIRemoteException;
0990:
0991: /**
0992: * return component info xml text for the specified binding component if
0993: * exists. If no binding component with that name exists, it returns the xml
0994: * with empty list.
0995: *
0996: * @param name
0997: * name of the binding component to lookup
0998: * @param state
0999: * return the binding component that is in the specified state.
1000: * valid states are JBIComponentInfo.STARTED, STOPPED, INSTALLED
1001: * or null for ANY state
1002: * @param sharedLibraryName
1003: * return the binding component that has a dependency on the
1004: * specified shared library. null value to ignore this option.
1005: * @param serviceAssemblyName
1006: * return the binding component that has the specified service
1007: * assembly deployed on it. null value to ignore this option.
1008: * @param targetName
1009: * name of the target for this operation
1010: * @return xml text contain the binding component info that confirms to the
1011: * component info list xml grammer.
1012: * @throws JBIRemoteException
1013: * if error or exception occurs.
1014: */
1015: public Map<String /* targetName */, String /* targetResult */> showBindingComponent(
1016: String name, String state, String sharedLibraryName,
1017: String serviceAssemblyName, String[] targetNames)
1018: throws JBIRemoteException;
1019:
1020: /**
1021: * return component info xml text for the specified shared library if
1022: * exists. If no shared library with that name exists, it returns the xml
1023: * with empty list.
1024: *
1025: * @param name
1026: * name of the shared library to lookup
1027: * @param componentName
1028: * return the shared library that is this component dependents.
1029: * null to ignore this option.
1030: * @param targetName
1031: * name of the target for this operation
1032: * @return xml string contain shared library component info that confirms to
1033: * the component info list xml grammer.
1034: * @throws JBIRemoteException
1035: * if error or exception occurs.
1036: */
1037: public Map<String /* targetName */, String /* targetResult */> showSharedLibrary(
1038: String name, String componentName, String[] targetNames)
1039: throws JBIRemoteException;
1040:
1041: /**
1042: * return service assembly info xml text for the specified service assembly
1043: * if exists. If no service assembly with that name exists, it returns the
1044: * xml with empty list.
1045: *
1046: * @param name
1047: * name of the service assembly to lookup
1048: * @param state
1049: * return the service assembly that is in the specified state.
1050: * JBIServiceAssemblyInfo.STARTED, STOPPED, SHUTDOWN or null for
1051: * ANY state
1052: * @param componentName
1053: * return the service assembly that has service units on this
1054: * component.
1055: * @param targetName
1056: * name of the target for this operation
1057: * @return xml string contain service assembly info that confirms to the
1058: * service assembly list xml grammer.
1059: * @throws JBIRemoteException
1060: * if error or exception occurs.
1061: */
1062: public Map<String /* targetName */, String /* targetResult */> showServiceAssembly(
1063: String name, String state, String componentName,
1064: String[] targetNames) throws JBIRemoteException;
1065:
1066: // ////////////////////////////////////////////////////////
1067: // -- Operations on the Domain Administration Server --
1068: // ////////////////////////////////////////////////////////
1069: /**
1070: * Checks to see if the JBI Runtime is enabled.
1071: *
1072: * @return true if JBI Runtime Framework is available, false if not
1073: * @throws JBIRemoteException
1074: * if error or exception occurs.
1075: */
1076: public boolean isJBIRuntimeEnabled() throws JBIRemoteException;
1077:
1078: /**
1079: * Returns the jbi.xml Installation Descriptor for a Service Engine/Binding
1080: * Component.
1081: *
1082: * @param the
1083: * name of the ServiceEngine or Binding Component
1084: * @return the jbi.xml deployment descriptor of the archive
1085: * @throws JBIRemoteException
1086: * if error or exception occurs.
1087: */
1088: public String getComponentInstallationDescriptor(
1089: String componentName) throws JBIRemoteException;
1090:
1091: /**
1092: * Returns the jbi.xml Installation Descriptor for a Shared Library.
1093: *
1094: * @param the
1095: * name of the Shared Library
1096: * @return the jbi.xml deployment descriptor of the archive
1097: * @throws JBIRemoteException
1098: * if error or exception occurs.
1099: */
1100: public String getSharedLibraryInstallationDescriptor(
1101: String sharedLibraryName) throws JBIRemoteException;
1102:
1103: /**
1104: * Returns the jbi.xml Deployment Descriptor for a Service Assembly.
1105: *
1106: * @param the
1107: * name of the Service Assembly
1108: * @return the jbi.xml deployment descriptor of the archive
1109: * @throws JBIRemoteException
1110: * if error or exception occurs.
1111: */
1112: public String getServiceAssemblyDeploymentDescriptor(
1113: String serviceAssemblyName) throws JBIRemoteException;
1114:
1115: /**
1116: * Returns the jbi.xml Deployment Descriptor for a Service Unit.
1117: *
1118: * @param the
1119: * name of the Service Assembly
1120: * @param the
1121: * name of the Service Unit
1122: * @return the jbi.xml deployment descriptor of the archive
1123: * @throws JBIRemoteException
1124: * if error or exception occurs.
1125: */
1126: public String getServiceUnitDeploymentDescriptor(
1127: String serviceAssemblyName, String serviceUnitName)
1128: throws JBIRemoteException;
1129:
1130: /**
1131: * installs component ( service engine, binding component)
1132: *
1133: * @param componentName
1134: * name of the component.
1135: * @param targetName
1136: * name of the target for this operation
1137: * @return result.
1138: * @throws JBIRemoteException
1139: * on error
1140: */
1141: public String installComponentFromDomain(String componentName,
1142: String targetName) throws JBIRemoteException;
1143:
1144: /**
1145: * installs component ( service engine, binding component)
1146: *
1147: * @param componentName
1148: * name of the component.
1149: * @param component
1150: * configuration properties
1151: * @param targetName
1152: * name of the target for this operation
1153: * @return result.
1154: * @throws JBIRemoteException
1155: * on error
1156: */
1157: public String installComponentFromDomain(String componentName,
1158: Properties properties, String targetName)
1159: throws JBIRemoteException;
1160:
1161: /**
1162: * uninstalls component ( service engine, binding component)
1163: *
1164: * @param componentName
1165: * name of the component
1166: * @param forceDelete
1167: * true to delete, false to not
1168: * @param targetName
1169: * name of the target for this operation
1170: * @return Map of targetName and component name strings.
1171: * @throws JBIRemoteException
1172: * on error
1173: */
1174:
1175: public String uninstallComponent(String componentName,
1176: boolean forceDelete, String targetName)
1177: throws JBIRemoteException;
1178:
1179: /**
1180: * installs shared library
1181: *
1182: * @param libraryName
1183: * Shared Library Name
1184: * @param targetName
1185: * name of the target for this operation
1186: * @return Map of targetName and shared library name strings.
1187: * @throws JBIRemoteException
1188: * on error
1189: */
1190: public String installSharedLibraryFromDomain(String libraryName,
1191: String targetName) throws JBIRemoteException;
1192:
1193: /**
1194: * uninstalls shared library
1195: *
1196: * @param sharedLibraryName
1197: * name of the shared library
1198: * @param forceDelete
1199: * true to delete, false to not
1200: * @param targetName
1201: * name of the target for this operation
1202: * @return Map of targetName and shared library name strings.
1203: * @throws JBIRemoteException
1204: * on error
1205: */
1206: public String uninstallSharedLibrary(String sharedLibraryName,
1207: boolean forceDelete, String targetName)
1208: throws JBIRemoteException;
1209:
1210: /**
1211: * deploys service assembly
1212: *
1213: * @param assemblyName
1214: * service assembly name
1215: * @param targetName
1216: * name of the target for this operation
1217: * @return Map of targetName and management message xml text strings.
1218: * @throws JBIRemoteException
1219: * on error
1220: */
1221: public String deployServiceAssemblyFromDomain(String assemblyName,
1222: String targetName) throws JBIRemoteException;
1223:
1224: /**
1225: * undeploys service assembly
1226: *
1227: * @param serviceAssemblyName
1228: * name of the service assembly
1229: * @param forceDelete
1230: * forces deletion of the assembly if true, false if not
1231: * @param targetName
1232: * name of the target for this operation
1233: * @return Map of targetName and result as a management message xml text
1234: * strings.
1235: * @throws JBIRemoteException
1236: * on error
1237: */
1238: public String undeployServiceAssembly(String serviceAssemblyName,
1239: boolean forceDelete, String targetName)
1240: throws JBIRemoteException;
1241:
1242: /**
1243: * installs component ( service engine, binding component)
1244: *
1245: * @param componentName
1246: * name of the component
1247: * @param targetNames
1248: * array of targets for this operation
1249: * @return Map of targetName and component name strings.
1250: * @throws JBIRemoteException
1251: * on error
1252: */
1253: public Map<String /* targetName */, String /* targetResult */> installComponentFromDomain(
1254: String componentName, String[] targetNames)
1255: throws JBIRemoteException;
1256:
1257: /**
1258: * installs component ( service engine, binding component)
1259: *
1260: * @param componentName
1261: * name of the component
1262: * @param targetNames
1263: * array of targets for this operation
1264: * @param component
1265: * configuration properties
1266: * @return Map of targetName and component name strings.
1267: * @throws JBIRemoteException
1268: * on error
1269: */
1270: public Map<String /* targetName */, String /* targetResult */> installComponentFromDomain(
1271: String componentName, Properties properties,
1272: String[] targetNames) throws JBIRemoteException;
1273:
1274: /**
1275: * uninstalls component ( service engine, binding component)
1276: *
1277: * @param componentName
1278: * name of the component
1279: * @param forceDelete
1280: * true to delete, false to not
1281: * @param targetName
1282: * name of the target for this operation
1283: * @return Map of targetName and component name strings.
1284: * @throws JBIRemoteException
1285: * on error
1286: */
1287: public Map<String /* targetName */, String /* targetResult */> uninstallComponent(
1288: String componentName, boolean forceDelete,
1289: String[] targetNames) throws JBIRemoteException;
1290:
1291: /**
1292: * installs shared library
1293: *
1294: * @param libraryName
1295: * name of the library
1296: * @param targetName
1297: * name of the target for this operation
1298: * @return Map of targetName and shared library name strings.
1299: * @throws JBIRemoteException
1300: * on error
1301: */
1302: public Map<String /* targetName */, String /* targetResult */> installSharedLibraryFromDomain(
1303: String libraryName, String[] targetNames)
1304: throws JBIRemoteException;
1305:
1306: /**
1307: * uninstalls shared library
1308: *
1309: * @param sharedLibraryName
1310: * name of the shared library
1311: * @param forceDelete
1312: * true to delete, false to not
1313: * @param targetName
1314: * name of the target for this operation
1315: * @return Map of targetName and shared library name strings.
1316: * @throws JBIRemoteException
1317: * on error
1318: */
1319: public Map<String /* targetName */, String /* targetResult */> uninstallSharedLibrary(
1320: String sharedLibraryName, boolean forceDelete,
1321: String[] targetNames) throws JBIRemoteException;
1322:
1323: /**
1324: * deploys service assembly
1325: *
1326: * @param assemblyName
1327: * name of the service assembly
1328: * @param targetName
1329: * name of the target for this operation
1330: * @return Map of targetName and management message xml text strings.
1331: * @throws JBIRemoteException
1332: * on error
1333: */
1334: public Map<String /* targetName */, String /* targetResult */> deployServiceAssemblyFromDomain(
1335: String assemblyName, String[] targetNames)
1336: throws JBIRemoteException;
1337:
1338: /**
1339: * undeploys service assembly
1340: *
1341: * @param serviceAssemblyName
1342: * name of the service assembly
1343: * @param forceDelete
1344: * true to delete, false to not
1345: * @param targetName
1346: * name of the target for this operation
1347: * @return Map of targetName and result as a management message xml text
1348: * strings.
1349: * @throws JBIRemoteException
1350: * on error
1351: */
1352: public Map<String /* targetName */, String /* targetResult */> undeployServiceAssembly(
1353: String serviceAssemblyName, boolean forceDelete,
1354: String[] targetNames) throws JBIRemoteException;
1355:
1356: // //////////////////////////////////
1357: // Retain in Domain
1358: // //////////////////////////////////
1359: /**
1360: * uninstalls component ( service engine, binding component)
1361: *
1362: * @param componentName
1363: * name of the component
1364: * @param forceDelete
1365: * true to delete, false to not
1366: * @param retainInDomain
1367: * true to not delete it from the domain target, false to also
1368: * delete it from the domain target.
1369: * @param targetName
1370: * name of the target for this operation
1371: * @return component name string.
1372: * @throws JBIRemoteException
1373: * on error
1374: */
1375:
1376: public String uninstallComponent(String componentName,
1377: boolean forceDelete, boolean retainInDomain,
1378: String targetName) throws JBIRemoteException;
1379:
1380: /**
1381: * uninstalls shared library
1382: *
1383: * @param sharedLibraryName
1384: * name of the shared library
1385: * @param forceDelete
1386: * true to delete, false to not
1387: * @param retainInDomain
1388: * true to not delete it from the domain target, false to also
1389: * delete it from the domain target.
1390: * @param targetName
1391: * name of the target for this operation
1392: * @return shared library name string.
1393: * @throws JBIRemoteException
1394: * on error
1395: */
1396: public String uninstallSharedLibrary(String sharedLibraryName,
1397: boolean forceDelete, boolean retainInDomain,
1398: String targetName) throws JBIRemoteException;
1399:
1400: /**
1401: * undeploys service assembly
1402: *
1403: * @param serviceAssemblyName
1404: * name of the service assembly
1405: * @param forceDelete
1406: * forces deletion of the assembly if true, false if not
1407: * @param retainInDomain
1408: * true to not delete it from the domain target, false to also
1409: * delete it from the domain target.
1410: * @param targetName
1411: * name of the target for this operation
1412: * @return result as a management message xml text string.
1413: * @throws JBIRemoteException
1414: * on error
1415: */
1416: public String undeployServiceAssembly(String serviceAssemblyName,
1417: boolean forceDelete, boolean retainInDomain,
1418: String targetName) throws JBIRemoteException;
1419:
1420: /**
1421: * uninstalls component ( service engine, binding component)
1422: *
1423: * @param componentName
1424: * name of the component
1425: * @param forceDelete
1426: * true to delete, false to not
1427: * @param retainInDomain
1428: * true to not delete it from the domain target, false to also
1429: * delete it from the domain target.
1430: * @param targetNames
1431: * array of targets for this operation
1432: * @return Map of targetName and component name strings.
1433: * @throws JBIRemoteException
1434: * on error
1435: */
1436:
1437: public Map<String /* targetName */, String /* targetResult */> uninstallComponent(
1438: String componentName, boolean forceDelete,
1439: boolean retainInDomain, String[] targetNames)
1440: throws JBIRemoteException;
1441:
1442: /**
1443: * uninstalls shared library
1444: *
1445: * @param sharedLibraryName
1446: * name of the shared library
1447: * @param forceDelete
1448: * true to delete, false to not
1449: * @param retainInDomain
1450: * true to not delete it from the domain target, false to also
1451: * delete it from the domain target.
1452: * @param targetNames
1453: * array of targets for this operation
1454: * @return Map of targetName and shared library name strings.
1455: * @throws JBIRemoteException
1456: * on error
1457: */
1458: public Map<String /* targetName */, String /* targetResult */> uninstallSharedLibrary(
1459: String sharedLibraryName, boolean forceDelete,
1460: boolean retainInDomain, String[] targetNames)
1461: throws JBIRemoteException;
1462:
1463: /**
1464: * undeploys service assembly
1465: *
1466: * @param serviceAssemblyName
1467: * name of the service assembly
1468: * @param forceDelete
1469: * forces deletion of the assembly if true, false if not
1470: * @param retainInDomain
1471: * true to not delete it from the domain target, false to also
1472: * delete it from the domain target.
1473: * @param targetNames
1474: * array of targets for this operation
1475: * @return Map of targetName and result as a management message xml text
1476: * strings.
1477: * @throws JBIRemoteException
1478: * on error
1479: */
1480: public Map<String /* targetName */, String /* targetResult */> undeployServiceAssembly(
1481: String serviceAssemblyName, boolean forceDelete,
1482: boolean retainInDomain, String[] targetNames)
1483: throws JBIRemoteException;
1484:
1485: /**
1486: * Gets the component custom loggers and their levels
1487: *
1488: * @param componentName
1489: * name of the component
1490: * @param targetName
1491: * name of the target (e.g., cluster1, server, etc.)
1492: * @param targetInstanceName
1493: * name of the target instance (e.g., cluster1-instance1, etc.)
1494: * @return a Map of loggerCustomName to their log levels
1495: * @throws JBIRemoteException
1496: * on error
1497: */
1498: public Map<String /* loggerCustomName */, Level /* logLevel */> getComponentLoggerLevels(
1499: String componentName, String targetName,
1500: String targetInstanceName) throws JBIRemoteException;
1501:
1502: /**
1503: * Gets the component custom loggers and their display names.
1504: *
1505: * @param componentName
1506: * name of the component
1507: * @param targetName
1508: * name of the target (e.g., cluster1, server, etc.)
1509: * @param targetInstanceName
1510: * name of the target instance (e.g., cluster1-instance1, etc.)
1511: * @return a Map of loggerCustomName to their log levels
1512: * @throws JBIRemoteException
1513: * on error
1514: */
1515: public Map<String /* loggerCustomName */, String /* displayName */> getComponentLoggerDisplayNames(
1516: String componentName, String targetName,
1517: String targetInstanceName) throws JBIRemoteException;
1518:
1519: /**
1520: * Sets the component log level for a given custom logger
1521: *
1522: * @param componentName
1523: * name of the component
1524: * @param loggerCustomName
1525: * the custom logger name
1526: * @param logLevel
1527: * the level to set the logger
1528: * @param targetName
1529: * name of the target (e.g., cluster1, server, etc.)
1530: * @param targetInstanceName
1531: * name of the target instance (e.g., cluster1-instance1, etc.)
1532: * @throws JBIRemoteException
1533: * on error
1534: */
1535: public void setComponentLoggerLevel(String componentName,
1536: String loggerCustomName, Level logLevel, String targetName,
1537: String targetInstanceName) throws JBIRemoteException;
1538:
1539: /**
1540: * Gets all the runtime loggers and their levels
1541: *
1542: * @param targetName
1543: * name of the target (e.g., cluster1, server, etc.)
1544: * @param targetInstanceName
1545: * name of the target instance (e.g., cluster1-instance1, etc.)
1546: * @return a Map of loggerCustomName to their log levels
1547: * @throws JBIRemoteException
1548: * on error
1549: */
1550: public Map<String /* runtimeLoggerName */, Level /* logLevel */> getRuntimeLoggerLevels(
1551: String targetName, String targetInstanceName)
1552: throws JBIRemoteException;
1553:
1554: /**
1555: * Lookup the level of one runtime logger
1556: *
1557: * @param runtimeLoggerName
1558: * name of the runtime logger (e.g. com.sun.jbi.framework
1559: * @param targetName
1560: * name of the target (e.g., cluster1, server, etc.)
1561: * @param targetInstanceName
1562: * name of the target instance (e.g., cluster1-instance1, etc.)
1563: * @return a Map of loggerCustomName to their log levels
1564: * @throws JBIRemoteException
1565: * on error
1566: */
1567: public Level getRuntimeLoggerLevel(String runtimeLoggerName,
1568: String targetName, String targetInstanceName)
1569: throws JBIRemoteException;
1570:
1571: /**
1572: * Sets the log level for a given runtime logger
1573: *
1574: * @param runtimeLoggerName
1575: * name of the runtime logger
1576: * @param logLevel
1577: * the level to set the logger
1578: * @param targetName
1579: * name of the target (e.g., cluster1, server, etc.)
1580: * @param targetInstanceName
1581: * name of the target instance (e.g., cluster1-instance1, etc.)
1582: * @throws JBIRemoteException
1583: * on error
1584: */
1585: public void setRuntimeLoggerLevel(String runtimeLoggerName,
1586: Level logLevel, String targetName, String targetInstanceName)
1587: throws JBIRemoteException;
1588:
1589: /**
1590: * Gets all the runtime loggers and their display names
1591: *
1592: * @param targetName
1593: * name of the target (e.g., cluster1, server, etc.)
1594: * @param targetInstanceName
1595: * name of the target instance (e.g., cluster1-instance1, etc.)
1596: * @return a Map of display names to their logger names
1597: * @throws JBIRemoteException
1598: * on error
1599: */
1600: public Map<String /* display name */, String /* logger name */> getRuntimeLoggerNames(
1601: String targetName, String targetInstanceName)
1602: throws JBIRemoteException;
1603:
1604: /**
1605: * Return the display name for a runtime logger
1606: *
1607: * @param runtimeLoggerName
1608: * name of the logger (e.g. com.sun.jbi.framework)
1609: * @param targetName
1610: * name of the target (e.g., cluster1, server, etc.)
1611: * @param targetInstanceName
1612: * name of the target instance (e.g., cluster1-instance1, etc.)
1613: * @return the display name for the given logger
1614: * @throws JBIRemoteException
1615: * on error
1616: */
1617: public String getRuntimeLoggerDisplayName(String runtimeLoggerName,
1618: String targetName, String targetInstanceName)
1619: throws JBIRemoteException;
1620:
1621: /**
1622: * Gets all the runtime loggers and their levels
1623: *
1624: * @param targetName
1625: * name of the target (e.g., cluster1, server, etc.)
1626: * @return a Map of loggerCustomName to their log levels
1627: * @throws JBIRemoteException
1628: * on error
1629: */
1630: public Map<String /* runtimeLoggerName */, Level /* logLevel */> getRuntimeLoggerLevels(
1631: String targetName) throws JBIRemoteException;
1632:
1633: /**
1634: * Lookup the level of one runtime logger
1635: *
1636: * @param runtimeLoggerName
1637: * name of the runtime logger (e.g. com.sun.jbi.framework
1638: * @param targetName
1639: * name of the target (e.g., cluster1, server, etc.)
1640: * @return a Map of loggerCustomName to their log levels
1641: * @throws JBIRemoteException
1642: * on error
1643: */
1644: public Level getRuntimeLoggerLevel(String runtimeLoggerName,
1645: String targetName) throws JBIRemoteException;
1646:
1647: /**
1648: * Sets the log level for a given runtime logger
1649: *
1650: * @param runtimeLoggerName
1651: * name of the runtime logger
1652: * @param logLevel
1653: * the level to set the logger
1654: * @param targetName
1655: * name of the target (e.g., cluster1, server, etc.)
1656: * @throws JBIRemoteException
1657: * on error
1658: */
1659: public void setRuntimeLoggerLevel(String runtimeLoggerName,
1660: Level logLevel, String targetName)
1661: throws JBIRemoteException;
1662:
1663: /**
1664: * Gets all the runtime loggers and their display names
1665: *
1666: * @param targetName
1667: * name of the target (e.g., cluster1, server, etc.)
1668: * @return a Map of display names to their logger names
1669: * @throws JBIRemoteException
1670: * on error
1671: */
1672: public Map<String /* display name */, String /* logger name */> getRuntimeLoggerNames(
1673: String targetName) throws JBIRemoteException;
1674:
1675: /**
1676: * Return the display name for a runtime logger
1677: *
1678: * @param runtimeLoggerName
1679: * name of the logger (e.g. com.sun.jbi.framework)
1680: * @param targetName
1681: * name of the target (e.g., cluster1, server, etc.)
1682: * @return the display name for the given logger
1683: * @throws JBIRemoteException
1684: * on error
1685: */
1686: public String getRuntimeLoggerDisplayName(String runtimeLoggerName,
1687: String targetName) throws JBIRemoteException;
1688:
1689: /**
1690: * Gets the extension MBean object names
1691: *
1692: * @param componentName
1693: * name of the component
1694: * @param extensionName
1695: * the name of the extension (e.g., Configuration, Logger, etc.)
1696: * @param targetName
1697: * name of the target (e.g., cluster1, server, etc.)
1698: * @return
1699: * @throws JBIRemoteException
1700: * on error
1701: */
1702: public Map<String /* targetInstanceName */, ObjectName[]> getComponentExtensionMBeanObjectNames(
1703: String componentName, String extensionName,
1704: String targetName) throws JBIRemoteException;
1705:
1706: /**
1707: * Gets the extension MBean object names
1708: *
1709: * @param componentName
1710: * name of the component
1711: * @param extensionName
1712: * the name of the extension (e.g., Configuration, Logger, etc.)
1713: * @param targetName
1714: * name of the target (e.g., cluster1, server, etc.)
1715: * @param targetInstanceName
1716: * name of the target instance (e.g., cluster1-instance1, etc.)
1717: * @return an array of ObjectName(s)
1718: * @throws JBIRemoteException
1719: * on error
1720: */
1721: public ObjectName[] getComponentExtensionMBeanObjectNames(
1722: String componentName, String extensionName,
1723: String targetName, String targetInstanceName)
1724: throws JBIRemoteException;
1725:
1726: /**
1727: * Retrieve component configuration
1728: *
1729: * @param componentName
1730: * @param targetName
1731: * @return the targetName as key and the name/value pairs as properties
1732: */
1733: Properties getComponentConfiguration(String componentName,
1734: String targetName) throws JBIRemoteException;
1735:
1736: /**
1737: * Will return jbi mgmt message with success, failure, or partial success
1738: * per instance. The entry per instance will have value as part of the
1739: * management message (XML) String.
1740: *
1741: * @param targetName the name of the JBI target
1742: * @param componentName the component name
1743: * @param configurationValues the configuration properties
1744: * @return
1745: */
1746: public String setComponentConfiguration(String targetName,
1747: String componentName, Properties configurationValues)
1748: throws JBIRemoteException;
1749:
1750: /**
1751: * updates component ( service engine, binding component)
1752: *
1753: * @param componentName
1754: * Name of the component to update.
1755: * @param zipFilePath
1756: * archive file in a zip format
1757: * @return The name of the component if successful
1758: * @throws JBIRemoteException
1759: * on error
1760: */
1761: public String updateComponent(String componentName,
1762: String zipFilePath) throws JBIRemoteException;
1763:
1764: /**
1765: * Checks to see if the Target (server, cluster) is up or down.
1766: *
1767: * @param targetName
1768: * name of the target (e.g., cluster1, server, etc.)
1769: * @return true if Target is up, false if not
1770: * @throws JBIRemoteException
1771: * if error or exception occurs.
1772: */
1773: public boolean isTargetUp(String targetName)
1774: throws JBIRemoteException;
1775:
1776: /**
1777: * This method returns the runtime configuration metadata associated with
1778: * the specified property. The metadata contain name-value pairs like:
1779: * default, descriptionID, descriptorType, displayName, displayNameId,
1780: * isStatic, name, resourceBundleName, tooltip, tooltipId, etc.
1781: *
1782: * @param propertyKeyName
1783: * @return Properties that represent runtime configuration metadata
1784: * @throws JBIRemoteException
1785: */
1786: Properties getRuntimeConfigurationMetaData(String propertyKeyName)
1787: throws JBIRemoteException;
1788:
1789: /**
1790: * This method sets one or more configuration parameters on the runtime with
1791: * a list of name/value pairs passed as a properties object. The property
1792: * name in the properties object should be an existing configuration
1793: * parameter name. If user try to set the parameter that is not in the
1794: * configuration parameters list, this method will throw an exception.
1795: *
1796: * The value of the property can be any object. If the value is non string
1797: * object, its string value (Object.toString()) will be used as a value that
1798: * will be set on the configuration.
1799: *
1800: * This method first validates whether all the paramters passed in
1801: * properties object exist in the runtime configuration or not. If any one
1802: * the parameters passed is not existing, it will return an error without
1803: * settings the parameters that are passed in the properties including a
1804: * valid parameters.
1805: *
1806: * If there is an error in setting a paramter, this method throws an
1807: * exception with the list of parameters that were not set.
1808: *
1809: * @param params
1810: * Properties object that contains name/value pairs corresponding
1811: * to the configuration parameters to be set on the runtime.
1812: *
1813: * @param targetName
1814: * cluster or instance name ( e.g. cluster1, instance1 ) on which
1815: * configuration parameters will be set. null to represent the
1816: * default instance which is admin server
1817: *
1818: * @return true if server restart is required, false if not
1819: *
1820: * @throws JBIRemoteException
1821: * if there is a jmx error or a invalid parameter is passed in
1822: * the params properties object. In case of an error setting the
1823: * a particular parameter, the error message should list the
1824: * invalid parameters.
1825: */
1826: public boolean setRuntimeConfiguration(Properties parameters,
1827: String targetName) throws JBIRemoteException;
1828:
1829: /**
1830: * This method returns a tabular data of a complex open data objects that
1831: * represent the runtime configuration parameter descriptor. The parameter
1832: * descriptor should contain the following data that represents the
1833: * parameter.
1834: *
1835: * name : name of the parameter value : value of the parameter as a String
1836: * type. type : type of the parameter. Basic data types only. description:
1837: * (optional) description of the parameter. displayName: (optional) display
1838: * name of the parameter readOnly : true/false validValues : (optional) list
1839: * of string values with ',' as delimiter. or a range value with - with a
1840: * '-' as delimiter. min and max strings will be converted to the parameter
1841: * type and then used to validate the value of the parameter.
1842: *
1843: * @param targetName
1844: * cluster or instance name ( e.g. cluster1, instance1 ) on which
1845: * configuration parameters will be set. null to represent the
1846: * default instance which is admin server
1847: *
1848: * @return Properties that represents the list of configuration parameter
1849: * descriptors.
1850: *
1851: * @throws JBIRemoteException
1852: * if there is a jmx error accessing the instance
1853: */
1854: public Properties getRuntimeConfiguration(String targetName)
1855: throws JBIRemoteException;
1856:
1857: /**
1858: * This method returns a tabular data of a complex open data objects that
1859: * represent the runtime configuration parameter descriptor. The parameter
1860: * descriptor should contain the following data that represents the
1861: * parameter.
1862: *
1863: * name : name of the parameter value : value of the parameter as a String
1864: * type. type : type of the parameter. Basic data types only. description:
1865: * (optional) description of the parameter. displayName: (optional) display
1866: * name of the parameter readOnly : true/false validValues : (optional) list
1867: * of string values with ',' as delimiter. or a range value with - with a
1868: * '-' as delimiter. min and max strings will be converted to the parameter
1869: * type and then used to validate the value of the parameter.
1870: *
1871: * @param targetName
1872: * cluster or instance name ( e.g. cluster1, instance1 ) on which
1873: * configuration parameters will be set. null to represent the
1874: * default instance which is admin server
1875: *
1876: * @return Properties that represents the list of configuration parameter
1877: * descriptors.
1878: *
1879: * @throws JBIRemoteException
1880: * if there is a jmx error accessing the instance
1881: */
1882: public Properties getDefaultRuntimeConfiguration()
1883: throws JBIRemoteException;
1884:
1885: /**
1886: * checks if the server need to be restarted to apply the changes made to
1887: * some of the configuration parameters.
1888: *
1889: * @return true if server needs to be restarted for updated configuration to
1890: * take effect. false if no server restart is needed.
1891: */
1892: public boolean isServerRestartRequired() throws JBIRemoteException;
1893:
1894: /**
1895: * This method is used to verify if the application variables and
1896: * application configuration objects used in the given
1897: * application are available in JBI runtime in the specified target.
1898: * Also this method verifies if all necessary components are installed.
1899: * If generateTemplates is true templates for missing application variables
1900: * and application configurations are generated. A command script that uses
1901: * the template files to set configuration objects is generated.
1902: *
1903: * @param applicationURL the URL for the application zip file
1904: * @param targetName the target on which the application has to be verified
1905: * @param generateTemplates true if templates have to be generated
1906: * @param templateDir the dir to store the generated templates
1907: * @param includeDeployCommand true if the generated script should include
1908: * deploy command
1909: *
1910: * @returns CompositeData the verification report
1911: *
1912: * CompositeType of verification report
1913: * String - "ServiceAssemblyName",
1914: * String - "ServiceAssemblyDescription",
1915: * Integer - "NumServiceUnits",
1916: * Boolean - "AllComponentsInstalled",
1917: * String[] - "MissingComponentsList",
1918: * CompositeData[] - "EndpointInfo",
1919: * CompositeData[] - "JavaEEVerifierReport"
1920: * String - "TemplateZIPID"
1921: *
1922: * CompositeType of each EndpointInfo
1923: * String - "EndpointName",
1924: * String - "ServiceUnitName",
1925: * String - "ComponentName",
1926: * String - "Status"
1927: * String[] - "MissingApplicationVariables"
1928: * String[] - "MissingApplicationConfigurations"
1929: *
1930: * CompositeType of each JavaEEVerifierReport
1931: * String - "ServiceUnitName"
1932: * TabularData - "JavaEEVerifierReport"
1933: *
1934: * TabularType of each JavaEEVerifierReport
1935: *
1936: * SimpleType.STRING - "Ear Filename"
1937: * SimpleType.STRING - "Referrence By"
1938: * SimpleType.STRING - "Referrence Class"
1939: * SimpleType.STRING - "JNDI Name"
1940: * SimpleType.STRING - "JNDI Class Type"
1941: * SimpleType.STRING - "Message"
1942: * SimpleType.INTEGER - "Status"
1943: *
1944: * @throws JBIRemoteException if the application could not be verified
1945: *
1946: * Note: param templateDir is used between ant/cli and common client client
1947: * TemplateZIPID is used between common client server and common client client
1948: */
1949: public CompositeData verifyApplication(String applicationURL,
1950: String targetName, boolean generateTemplates,
1951: String templateDir, boolean includeDeployCommand)
1952: throws JBIRemoteException;
1953:
1954: /**
1955: * This method is used to export the application variables and
1956: * application configuration objects used by the given
1957: * application in the specified target.
1958: *
1959: * @param applicationName the name of the application
1960: * @param targetName the target whose configuration has to be exported
1961: * @param configDir the dir to store the configurations
1962: * @return String the id for the zip file with exported configurations
1963: *
1964: * @throws JBIRemoteException if the application configuration could not be exported
1965: *
1966: * Note: param configDir is used between ant/cli and common client client.
1967: * The return value is used between common client server and common client client.
1968: */
1969: public String exportApplicationConfiguration(
1970: String applicationName, String targetName, String configDir)
1971: throws JBIRemoteException;
1972:
1973: /*----------------------------------------------------------------------------------*\
1974: * Operations for Application Variable Management *
1975: \*----------------------------------------------------------------------------------*/
1976:
1977: /**
1978: * Detect the components support for application variables. This method
1979: * returns true if the component has a configuration MBean and implements
1980: * all the operations for application variable management.
1981: *
1982: * @param componentName
1983: * component identification
1984: * @param targetName
1985: * identification of the target. Can be a standalone server,
1986: * cluster or clustered instance.
1987: * @return true if the components configuration MBean implements all the
1988: * operations for application variables.
1989: * @throws JBIRemoteException if the component is not installed or is not
1990: * in the Started state.
1991: *
1992: */
1993: public boolean isAppVarsSupported(String componentName,
1994: String targetName) throws JBIRemoteException;
1995:
1996: /**
1997: * Add application variables to a component installed on a given target. If even a
1998: * variable from the set is already set on the component, this operation fails.
1999: *
2000: * @param componentName
2001: * component identification
2002: * @param targetName
2003: * identification of the target. Can be a standalone server,
2004: * cluster or clustered instance.
2005: * @param appVariables - set of application variables to add. The values of the
2006: * application variables have the application variable type and
2007: * value and the format is "[type]value"
2008: * @return
2009: * a JBI Management message indicating the status of the operation.
2010: * In case a variable is not added the management message has a
2011: * ERROR task status message giving the details of the failure.
2012: * @throws JBIRemoteException
2013: * if there is a jmx error accessing the instance
2014: */
2015: public String addApplicationVariables(String componentName,
2016: String targetName, Properties appVariables)
2017: throws JBIRemoteException;
2018:
2019: /**
2020: * Set application variables on a component installed on a given target. If even a
2021: * variable from the set has not been added to the component, this operation fails.
2022: *
2023: * @param componentName
2024: * component identification
2025: * @param targetName
2026: * identification of the target. Can be a standalone server,
2027: * cluster or clustered instance.
2028: * @param appVariables - set of application variables to update. The values of the
2029: * application variables have the application variable type and
2030: * value and the format is "[type]value"
2031: * @return
2032: * a JBI Management message indicating the status of the operation.
2033: * In case a variable is not set the management message has a
2034: * ERROR task status message giving the details of the failure.
2035: * @throws JBIRemoteException
2036: * if there is a jmx error accessing the instance
2037: */
2038: public String setApplicationVariables(String componentName,
2039: String targetName, Properties appVariables)
2040: throws JBIRemoteException;
2041:
2042: /**
2043: * Delete application variables from a component installed on a given target. If even a
2044: * variable from the set has not been added to the component, this operation fails.
2045: *
2046: * @param componentName
2047: * component identification
2048: * @param targetName
2049: * identification of the target. Can be a standalone server,
2050: * cluster or clustered instance.
2051: * @param appVariableNames - names of application variables to delete.
2052: * @return
2053: * a JBI Management message indicating the status of the operation.
2054: * In case a variable is not deleted the management message has a
2055: * ERROR task status message giving the details of the failure.
2056: * @throws JBIRemoteException
2057: * if there is a jmx error accessing the instance
2058: */
2059: public String deleteApplicationVariables(String componentName,
2060: String targetName, String[] appVariableNames)
2061: throws JBIRemoteException;
2062:
2063: /**
2064: * Get all the application variables set on a component.
2065: *
2066: * @return all the application variables et on the component. The return proerties
2067: * set has the name="[type]value" pairs for the application variables.
2068: * @return
2069: * a JBI Management message indicating the status of the operation.
2070: * @throws JBIRemoteException
2071: * if there is a jmx error accessing the instance
2072: */
2073: public Properties getApplicationVariables(String componentName,
2074: String targetName) throws JBIRemoteException;
2075:
2076: /*----------------------------------------------------------------------------------*\
2077: * Operations for Application Configuration Management *
2078: \*----------------------------------------------------------------------------------*/
2079:
2080: /**
2081: * Detect the components support for application configuration. This method
2082: * returns true if the component has a configuration MBean and implements
2083: * all the operations for application configuration management.
2084: *
2085: * @param componentName
2086: * component identification
2087: * @param targetName
2088: * identification of the target. Can be a standalone server,
2089: * cluster or clustered instance.
2090: * @return true if the components configuration MBean implements all the
2091: * operations for application configuration.
2092: * @throws JBIRemoteException if the component is not installed or is not
2093: * in the Started state.
2094: *
2095: */
2096: public boolean isAppConfigSupported(String componentName,
2097: String targetName) throws JBIRemoteException;
2098:
2099: /**
2100: * Get the CompositeType definition for the components application configuration
2101: *
2102: * @param componentName
2103: * component identification
2104: * @param targetName
2105: * identification of the target. Can be a standalone server,
2106: * cluster or clustered instance.
2107: * @return the CompositeType for the components application configuration.
2108: */
2109: public javax.management.openmbean.CompositeType queryApplicationConfigurationType(
2110: String componentName, String targetName)
2111: throws JBIRemoteException;
2112:
2113: /**
2114: * Add a named application configuration to a component installed on a given target.
2115: *
2116: * @param componentName
2117: * component identification
2118: * @param targetName
2119: * identification of the target. Can be a standalone server,
2120: * cluster or clustered instance.
2121: * @param name
2122: * application configuration name
2123: * @param config
2124: * application configuration represented as a set of properties.
2125: * @return
2126: * a JBI Management message indicating the status of the operation.
2127: * @throws JBIRemoteException
2128: * if there is a jmx error accessing the instance
2129: */
2130: public String addApplicationConfiguration(String componentName,
2131: String targetName, String name, Properties config)
2132: throws JBIRemoteException;
2133:
2134: /**
2135: * Update a named application configuration in a component installed on a given target.
2136: *
2137: * @param componentName
2138: * component identification
2139: * @param targetName
2140: * identification of the target. Can be a standalone server,
2141: * cluster or clustered instance.
2142: * @param name
2143: * application configuration name
2144: * @param config
2145: * application configuration represented as a set of properties.
2146: * @return
2147: * a JBI Management message indicating the status of the operation.
2148: * @throws JBIRemoteException
2149: * if there is a jmx error accessing the instance
2150: */
2151: public String setApplicationConfiguration(String componentName,
2152: String targetName, String name, Properties config)
2153: throws JBIRemoteException;
2154:
2155: /**
2156: * Delete a named application configuration in a component installed on a given target.
2157: *
2158: * @param componentName
2159: * component identification
2160: * @param targetName
2161: * identification of the target. Can be a standalone server,
2162: * cluster or clustered instance.
2163: * @param name
2164: * name of application configuration to be deleted
2165: * @return
2166: * a JBI Management message indicating the status of the operation.
2167: * @throws JBIRemoteException
2168: * if there is a jmx error accessing the instance
2169: */
2170: public String deleteApplicationConfiguration(String componentName,
2171: String targetName, String name) throws JBIRemoteException;
2172:
2173: /**
2174: * List all the application configurations in a component.
2175: *
2176: * @param componentName
2177: * component identification
2178: * @param targetName
2179: * identification of the target. Can be a standalone server,
2180: * cluster or clustered instance.
2181: * @return
2182: * an array of names of all the application configurations.
2183: * @throws JBIRemoteException
2184: * if there is a jmx error accessing the instance
2185: */
2186: public String[] listApplicationConfigurationNames(
2187: String componentName, String targetName)
2188: throws JBIRemoteException;
2189:
2190: /**
2191: * Get a specific named configuration. If the named configuration does not exist
2192: * in the component the returned properties is an empty set.
2193: *
2194: * @param componentName
2195: * component identification
2196: * @param targetName
2197: * identification of the target. Can be a standalone server,
2198: * cluster or clustered instance.
2199: * @return the application configuration represented as a set of properties.
2200: * @throws JBIRemoteException
2201: * if there is a jmx error accessing the instance
2202: */
2203: public Properties getApplicationConfiguration(String componentName,
2204: String targetName, String name) throws JBIRemoteException;
2205:
2206: /**
2207: * Get all the application configurations set on a component.
2208: *
2209: * @param componentName
2210: * component identification
2211: * @param targetName
2212: * identification of the target. Can be a standalone server,
2213: * cluster or clustered instance.
2214: * @return
2215: * a map of all the application configurations keyed by the
2216: * configuration name.
2217: * @throws JBIRemoteException
2218: * if there is a jmx error accessing the instance
2219: */
2220: public Map<String, Properties> getApplicationConfigurations(
2221: String componentName, String targetName)
2222: throws JBIRemoteException;
2223:
2224: /**
2225: * Retrieves the component specific configuration schema.
2226: *
2227: * @param componentName
2228: * component identification
2229: * @param targetName
2230: * identification of the target. Can be a standalone server,
2231: * cluster or clustered instance.
2232: * @return a String containing the configuration schema.
2233: */
2234: public String retrieveConfigurationDisplaySchema(
2235: String componentName, String targetname)
2236: throws JBIRemoteException;;
2237:
2238: /**
2239: * Retrieves the component configuration metadata.
2240: * The XML data conforms to the component
2241: * configuration schema.
2242: *
2243: * @param componentName
2244: * component identification
2245: * @param targetName
2246: * identification of the target. Can be a standalone server,
2247: * cluster or clustered instance.
2248: * @return a String containing the configuration metadata.
2249: */
2250: public String retrieveConfigurationDisplayData(
2251: String componentName, String targetName)
2252: throws JBIRemoteException;
2253:
2254: /**
2255: * Detect the components support for component configuration. This method
2256: * returns true if the component has a configuration MBean with configurable
2257: * attributes
2258: *
2259: * @param componentName
2260: * component identification
2261: * @param targetName
2262: * identification of the target. Can be a standalone server,
2263: * cluster or clustered instance.
2264: * @return true if the components configuration MBean has configuration
2265: * attributes
2266: * @throws JBIRemoteException if the component is not installed or is not
2267: * in the Started state.
2268: *
2269: */
2270: public boolean isComponentConfigSupported(String componentName,
2271: String targetName) throws JBIRemoteException;
2272:
2273: /**
2274: * This method is used to provide JBIFramework statistics in the
2275: * given target.
2276: * @param target target name.
2277: * @return TabularData table of framework statistics in the given target.
2278: *
2279: * If the target is a standalone instance the table will have one entry.
2280: * If the target is a cluster the table will have an entry for each instance.
2281: *
2282: * For more information about the type of the entries in table please refer
2283: * to <code>JBIStatisticsMBean</code>
2284: */
2285: public TabularData getFrameworkStats(String targetName)
2286: throws JBIRemoteException;
2287:
2288: /**
2289: * This method is used to provide statistics for the given component
2290: * in the given target
2291: * @param targetName target name
2292: * @param componentName component name
2293: * @return TabularData table of component statistics
2294: *
2295: * If the target is a standalone instance the table will have one entry.
2296: * If the target is a cluster the table will have an entry for each instance.
2297: *
2298: * For more information about the type of the entries in table please refer
2299: * to <code>JBIStatisticsMBean</code>
2300: *
2301: */
2302: public TabularData getComponentStats(String componentName,
2303: String targetName) throws JBIRemoteException;
2304:
2305: /**
2306: * This method is used to provide statistic information about the given
2307: * endpoint in the given target
2308: * @param targetName target name
2309: * @param endpointName the endpoint Name
2310: * @return TabularData table of endpoint statistics
2311: *
2312: * If the target is a standalone instance the table will have one entry.
2313: * If the target is a cluster the table will have an entry for each instance.
2314: *
2315: * For more information about the type of the entries in table please refer
2316: * to <code>JBIStatisticsMBean</code>
2317: */
2318: public TabularData getEndpointStats(String endpointName,
2319: String targetName) throws JBIRemoteException;
2320:
2321: /**
2322: * This method is used to provide statistics about the message service in the
2323: * given target.
2324: * @param target target name.
2325: * @return TabularData table of NMR statistics in the given target.
2326: *
2327: * If the target is a standalone instance the table will have one entry.
2328: * If the target is a cluster the table will have an entry for each instance.
2329: *
2330: * For more information about the type of the entries in table please refer
2331: * to <code>JBIStatisticsMBean</code>
2332: */
2333: public TabularData getNMRStats(String targetName)
2334: throws JBIRemoteException;
2335:
2336: /**
2337: * This method is used to provide statistics about a Service Assembly
2338: * in the given target.
2339: * @param target target name.
2340: * @param saName the service assembly name.
2341: * @return TabularData table of NMR statistics in the given target.
2342: *
2343: * If the target is a standalone instance the table will have one entry.
2344: * If the target is a cluster the table will have an entry for each instance.
2345: *
2346: * For more information about the type of the entries in table please refer
2347: * to <code>JBIStatisticsMBean</code>
2348: */
2349: public TabularData getServiceAssemblyStats(String saName,
2350: String targetName) throws JBIRemoteException;
2351:
2352: /**
2353: * This method is used to provide a list of consuming endpoints for a component.
2354: * @param componentName component name
2355: * @param target target name.
2356: * @return TabularData list of consuming endpoints
2357: * @throws JBIRemoteException if the list of endpoints could not be obtained.
2358: *
2359: * If the target is a standalone instance the table will have one entry.
2360: * If the target is a cluster the table will have an entry for each instance.
2361: *
2362: * Each entry in this tabular data is of the following composite type
2363: *
2364: * String - "InstanceName",
2365: * String[] - "Endpoints",
2366: */
2367: public TabularData getConsumingEndpointsForComponent(
2368: String componentName, String targetName)
2369: throws JBIRemoteException;
2370:
2371: /**
2372: * This method is used to provide a list of provisioning endpoints for a component.
2373: * @param componentName component name
2374: * @param target target name.
2375: * @return TabularData list of provisioning endpoints
2376: * @throws JBIRemoteException if the list of endpoints could not be obtained.
2377: *
2378: * If the target is a standalone instance the table will have one entry.
2379: * If the target is a cluster the table will have an entry for each instance.
2380: *
2381: * Each entry in this tabular data is of the following composite type
2382: *
2383: * String - "InstanceName",
2384: * String[] - "Endpoints",
2385: */
2386: public TabularData getProvidingEndpointsForComponent(
2387: String componentName, String targetName)
2388: throws JBIRemoteException;
2389:
2390: }
|