OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libjava/] [classpath/] [javax/] [management/] [MBeanServer.java] - Blame information for rev 772

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 772 jeremybenn
/* MBeanServer.java -- Represents a management server.
2
   Copyright (C) 2006 Free Software Foundation, Inc.
3
 
4
This file is part of GNU Classpath.
5
 
6
GNU Classpath is free software; you can redistribute it and/or modify
7
it under the terms of the GNU General Public License as published by
8
the Free Software Foundation; either version 2, or (at your option)
9
any later version.
10
 
11
GNU Classpath is distributed in the hope that it will be useful, but
12
WITHOUT ANY WARRANTY; without even the implied warranty of
13
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
General Public License for more details.
15
 
16
You should have received a copy of the GNU General Public License
17
along with GNU Classpath; see the file COPYING.  If not, write to the
18
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
19
02110-1301 USA.
20
 
21
Linking this library statically or dynamically with other modules is
22
making a combined work based on this library.  Thus, the terms and
23
conditions of the GNU General Public License cover the whole
24
combination.
25
 
26
As a special exception, the copyright holders of this library give you
27
permission to link this library with independent modules to produce an
28
executable, regardless of the license terms of these independent
29
modules, and to copy and distribute the resulting executable under
30
terms of your choice, provided that you also meet, for each linked
31
independent module, the terms and conditions of the license of that
32
module.  An independent module is a module which is not derived from
33
or based on this library.  If you modify this library, you may extend
34
this exception to your version of the library, but you are not
35
obligated to do so.  If you do not wish to do so, delete this
36
exception statement from your version. */
37
 
38
package javax.management;
39
 
40
import java.io.ObjectInputStream;
41
 
42
import java.util.Set;
43
 
44
import javax.management.loading.ClassLoaderRepository;
45
 
46
/**
47
 * <p>
48
 * This interface represents a server for management beans,
49
 * providing facilities for the creation, registration and
50
 * removal of such beans.  This interface is central to the
51
 * Java management architecture.  Users do not usually implement
52
 * this class.  Instead, implementations of this class
53
 * may be obtained using an {@link MBeanServerFactory}.
54
 * </p>
55
 * <p>
56
 * Registering a bean with the server makes its attributes and
57
 * operations accessible via the server.  Only JMX compliant
58
 * beans may be registered with the server.  When a bean
59
 * is registered or unregistered, an {@link MBeanServerNotification}
60
 * is emitted by the server's {@link MBeanServerDelegate}.
61
 * Listeners may be registered with this bean in order to
62
 * obtain such notifications.  It has the {@link ObjectName}
63
 * <code>JMImplementation:type=MBeanServerDelegate</code>.
64
 * </p>
65
 * <p>
66
 * Security checks are applied on the methods of the server,
67
 * as detailed below, if it is obtained using the
68
 * {@link MBeanServerFactory#createMBeanServer()} or
69
 * {@link MBeanServerFactory#newMBeanServer()} methods and
70
 * {@link System.getSecurityManager()} returns a non-<code>null</code>
71
 * value.  If a check fails, a {@link SecurityException}
72
 * is thrown.  Note than the class name used in the exception
73
 * is that of the bean, and thus, as a result, an
74
 * {@link InstanceNotFoundException}
75
 * precludes these security checks, due to the class name
76
 * that would be used in the exception being unavailable.
77
 * </p>
78
 *
79
 * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
80
 * @since 1.5
81
 */
82
public interface MBeanServer
83
  extends MBeanServerConnection
84
{
85
 
86
  /**
87
   * Registers the supplied listener with the specified management
88
   * bean.  Notifications emitted by the management bean are forwarded
89
   * to the listener via the server, which will convert any MBean
90
   * references in the source to portable {@link ObjectName}
91
   * instances.  The notification is otherwise unchanged.
92
   *
93
   * @param name the name of the management bean with which the listener
94
   *             should be registered.
95
   * @param listener the listener which will handle notifications from
96
   *                 the bean.
97
   * @param filter the filter to apply to incoming notifications, or
98
   *               <code>null</code> if no filtering should be applied.
99
   * @param passback an object to be passed to the listener when a
100
   *                 notification is emitted.
101
   * @throws InstanceNotFoundException if the name of the management bean
102
   *                                   could not be resolved.
103
   * @throws SecurityException if a security manager exists and the
104
   *                           caller's permissions don't imply {@link
105
   *                           MBeanPermission(String,String,ObjectName,String)
106
   *                           <code>MBeanPermission(className, null, name,
107
   *                           "addNotificationListener")</code>}.
108
   * @see #removeNotificationListener(ObjectName, NotificationListener)
109
   * @see #removeNotificationListener(ObjectName, NotificationListener,
110
   *                                  NotificationFilter, Object)
111
   * @see NotificationBroadcaster#addNotificationListener(NotificationListener,
112
   *                                                      NotificationFilter,
113
   *                                                      Object)
114
   */
115
  void addNotificationListener(ObjectName name, NotificationListener listener,
116
                               NotificationFilter filter, Object passback)
117
    throws InstanceNotFoundException;
118
 
119
  /**
120
   * <p>
121
   * Registers the supplied listener with the specified management
122
   * bean.  Notifications emitted by the management bean are forwarded
123
   * to the listener via the server, which will convert any MBean
124
   * references in the source to portable {@link ObjectName}
125
   * instances.  The notification is otherwise unchanged.
126
   * </p>
127
   * <p>
128
   * The listener that receives notifications will be the one that is
129
   * registered with the given name at the time this method is called.
130
   * Even if it later unregisters and ceases to use that name, it will
131
   * still receive notifications.
132
   * </p>
133
   *
134
   * @param name the name of the management bean with which the listener
135
   *             should be registered.
136
   * @param listener the name of the listener which will handle
137
   *                 notifications from the bean.
138
   * @param filter the filter to apply to incoming notifications, or
139
   *               <code>null</code> if no filtering should be applied.
140
   * @param passback an object to be passed to the listener when a
141
   *                 notification is emitted.
142
   * @throws InstanceNotFoundException if the name of the management bean
143
   *                                   could not be resolved.
144
   * @throws RuntimeOperationsException if the bean associated with the given
145
   *                                    object name is not a
146
   *                                    {@link NotificationListener}.  This
147
   *                                    exception wraps an
148
   *                                    {@link IllegalArgumentException}.
149
   * @throws SecurityException if a security manager exists and the
150
   *                           caller's permissions don't imply {@link
151
   *                           MBeanPermission(String,String,ObjectName,String)
152
   *                           <code>MBeanPermission(className, null, name,
153
   *                           "addNotificationListener")</code>}.
154
   * @see #removeNotificationListener(ObjectName, NotificationListener)
155
   * @see #removeNotificationListener(ObjectName, NotificationListener,
156
   *                                  NotificationFilter, Object)
157
   * @see NotificationBroadcaster#addNotificationListener(NotificationListener,
158
   *                                                      NotificationFilter,
159
   *                                                      Object)
160
   */
161
  void addNotificationListener(ObjectName name, ObjectName listener,
162
                               NotificationFilter filter, Object passback)
163
    throws InstanceNotFoundException;
164
 
165
  /**
166
   * <p>
167
   * Instantiates a new instance of the specified management bean
168
   * using the default constructor and registers it with the server
169
   * under the supplied name.  The class is loaded using the
170
   * {@link javax.management.loading.ClassLoaderRepository default
171
   * loader repository} of the server.
172
   * </p>
173
   * <p>
174
   * If the name supplied is <code>null</code>, then the bean is
175
   * expected to implement the {@link MBeanRegistration} interface.
176
   * The {@link MBeanRegistration#preRegister preRegister} method
177
   * of this interface will be used to obtain the name in this case.
178
   * </p>
179
   * <p>
180
   * This method is equivalent to calling {@link
181
   * #createMBean(String, ObjectName, Object[], String[])
182
   * <code>createMBean(className, name, (Object[]) null,
183
   * (String[]) null)</code>} with <code>null</code> parameters
184
   * and signature.
185
   * </p>
186
   *
187
   * @param className the class of the management bean, of which
188
   *                  an instance should be created.
189
   * @param name the name to register the new bean with.
190
   * @return an {@link ObjectInstance} containing the {@link ObjectName}
191
   *         and Java class name of the created instance.
192
   * @throws ReflectionException if an exception occurs in creating
193
   *                             an instance of the bean.
194
   * @throws InstanceAlreadyExistsException if a matching instance
195
   *                                        already exists.
196
   * @throws MBeanRegistrationException if an exception occurs in
197
   *                                    calling the preRegister
198
   *                                    method.
199
   * @throws MBeanException if the bean's constructor throws an exception.
200
   * @throws NotCompliantMBeanException if the created bean is not
201
   *                                    compliant with the JMX specification.
202
   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
203
   *                                    is thrown by the server due to a
204
   *                                    <code>null</code> class name or object
205
   *                                    name or if the object name is a pattern.
206
   * @throws SecurityException if a security manager exists and the
207
   *                           caller's permissions don't imply the
208
   *                           use of the <code>instantiate</code>
209
   *                           and <code>registerMBean</code> methods.
210
   * @see #createMBean(String, ObjectName, Object[], String[])
211
   */
212
  ObjectInstance createMBean(String className, ObjectName name)
213
    throws ReflectionException, InstanceAlreadyExistsException,
214
           MBeanRegistrationException, MBeanException,
215
           NotCompliantMBeanException;
216
 
217
  /**
218
   * <p>
219
   * Instantiates a new instance of the specified management bean
220
   * using the given constructor and registers it with the server
221
   * under the supplied name.  The class is loaded using the
222
   * {@link javax.management.loading.ClassLoaderRepository default
223
   * loader repository} of the server.
224
   * </p>
225
   * <p>
226
   * If the name supplied is <code>null</code>, then the bean is
227
   * expected to implement the {@link MBeanRegistration} interface.
228
   * The {@link MBeanRegistration#preRegister preRegister} method
229
   * of this interface will be used to obtain the name in this case.
230
   * </p>
231
   *
232
   * @param className the class of the management bean, of which
233
   *                  an instance should be created.
234
   * @param name the name to register the new bean with.
235
   * @param params the parameters for the bean's constructor.
236
   * @param sig the signature of the constructor to use.
237
   * @return an {@link ObjectInstance} containing the {@link ObjectName}
238
   *         and Java class name of the created instance.
239
   * @throws ReflectionException if an exception occurs in creating
240
   *                             an instance of the bean.
241
   * @throws InstanceAlreadyExistsException if a matching instance
242
   *                                        already exists.
243
   * @throws MBeanRegistrationException if an exception occurs in
244
   *                                    calling the preRegister
245
   *                                    method.
246
   * @throws MBeanException if the bean's constructor throws an exception.
247
   * @throws NotCompliantMBeanException if the created bean is not
248
   *                                    compliant with the JMX specification.
249
   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
250
   *                                    is thrown by the server due to a
251
   *                                    <code>null</code> class name or object
252
   *                                    name or if the object name is a pattern.
253
   * @throws SecurityException if a security manager exists and the
254
   *                           caller's permissions don't imply the
255
   *                           use of the <code>instantiate</code>
256
   *                           and <code>registerMBean</code> methods.
257
   */
258
  ObjectInstance createMBean(String className, ObjectName name,
259
                             Object[] params, String[] sig)
260
    throws ReflectionException, InstanceAlreadyExistsException,
261
           MBeanRegistrationException, MBeanException,
262
           NotCompliantMBeanException;
263
 
264
  /**
265
   * <p>
266
   * Instantiates a new instance of the specified management bean
267
   * using the default constructor and registers it with the server
268
   * under the supplied name.  The class is loaded using the
269
   * given class loader.  If this argument is <code>null</code>,
270
   * then the same class loader as was used to load the server
271
   * is used.
272
   * </p>
273
   * <p>
274
   * If the name supplied is <code>null</code>, then the bean is
275
   * expected to implement the {@link MBeanRegistration} interface.
276
   * The {@link MBeanRegistration#preRegister preRegister} method
277
   * of this interface will be used to obtain the name in this case.
278
   * </p>
279
   * <p>
280
   * This method is equivalent to calling {@link
281
   * #createMBean(String, ObjectName, ObjectName, Object[], String)
282
   * <code>createMBean(className, name, loaderName, (Object[]) null,
283
   * (String) null)</code>} with <code>null</code> parameters
284
   * and signature.
285
   * </p>
286
   *
287
   * @param className the class of the management bean, of which
288
   *                  an instance should be created.
289
   * @param name the name to register the new bean with.
290
   * @param loaderName the name of the class loader.
291
   * @return an {@link ObjectInstance} containing the {@link ObjectName}
292
   *         and Java class name of the created instance.
293
   * @throws ReflectionException if an exception occurs in creating
294
   *                             an instance of the bean.
295
   * @throws InstanceAlreadyExistsException if a matching instance
296
   *                                        already exists.
297
   * @throws MBeanRegistrationException if an exception occurs in
298
   *                                    calling the preRegister
299
   *                                    method.
300
   * @throws MBeanException if the bean's constructor throws an exception.
301
   * @throws NotCompliantMBeanException if the created bean is not
302
   *                                    compliant with the JMX specification.
303
   * @throws InstanceNotFoundException if the specified class loader is not
304
   *                                   registered with the server.
305
   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
306
   *                                    is thrown by the server due to a
307
   *                                    <code>null</code> class name or object
308
   *                                    name or if the object name is a pattern.
309
   * @throws SecurityException if a security manager exists and the
310
   *                           caller's permissions don't imply the
311
   *                           use of the <code>instantiate</code>
312
   *                           and <code>registerMBean</code> methods.
313
   * @see #createMBean(String, ObjectName, ObjectName, Object[], String[])
314
   */
315
  ObjectInstance createMBean(String className, ObjectName name,
316
                             ObjectName loaderName)
317
    throws ReflectionException, InstanceAlreadyExistsException,
318
           MBeanRegistrationException, MBeanException,
319
           NotCompliantMBeanException, InstanceNotFoundException;
320
 
321
  /**
322
   * <p>
323
   * Instantiates a new instance of the specified management bean
324
   * using the given constructor and registers it with the server
325
   * under the supplied name.  The class is loaded using the
326
   * given class loader.  If this argument is <code>null</code>,
327
   * then the same class loader as was used to load the server
328
   * is used.
329
   * </p>
330
   * <p>
331
   * If the name supplied is <code>null</code>, then the bean is
332
   * expected to implement the {@link MBeanRegistration} interface.
333
   * The {@link MBeanRegistration#preRegister preRegister} method
334
   * of this interface will be used to obtain the name in this case.
335
   * </p>
336
   *
337
   * @param className the class of the management bean, of which
338
   *                  an instance should be created.
339
   * @param name the name to register the new bean with.
340
   * @param loaderName the name of the class loader.
341
   * @param params the parameters for the bean's constructor.
342
   * @param sig the signature of the constructor to use.
343
   * @return an {@link ObjectInstance} containing the {@link ObjectName}
344
   *         and Java class name of the created instance.
345
   * @throws ReflectionException if an exception occurs in creating
346
   *                             an instance of the bean.
347
   * @throws InstanceAlreadyExistsException if a matching instance
348
   *                                        already exists.
349
   * @throws MBeanRegistrationException if an exception occurs in
350
   *                                    calling the preRegister
351
   *                                    method.
352
   * @throws MBeanException if the bean's constructor throws an exception.
353
   * @throws NotCompliantMBeanException if the created bean is not
354
   *                                    compliant with the JMX specification.
355
   * @throws InstanceNotFoundException if the specified class loader is not
356
   *                                   registered with the server.
357
   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
358
   *                                    is thrown by the server due to a
359
   *                                    <code>null</code> class name or object
360
   *                                    name or if the object name is a pattern.
361
   * @throws SecurityException if a security manager exists and the
362
   *                           caller's permissions don't imply the
363
   *                           use of the <code>instantiate</code>
364
   *                           and <code>registerMBean</code> methods.
365
   */
366
  ObjectInstance createMBean(String className, ObjectName name,
367
                             ObjectName loaderName, Object[] params,
368
                             String[] sig)
369
    throws ReflectionException, InstanceAlreadyExistsException,
370
           MBeanRegistrationException, MBeanException,
371
           NotCompliantMBeanException, InstanceNotFoundException;
372
 
373
  /**
374
   * Deserializes a byte array using the class loader of the specified
375
   * management bean as its context.
376
   *
377
   * @param name the name of the bean whose class loader should be used.
378
   * @param data the byte array to be deserialized.
379
   * @return the deserialized object stream.
380
   * @deprecated {@link #getClassLoaderFor(ObjectName)} should be used
381
   *             to obtain the class loader of the bean, which can then
382
   *             be used to perform deserialization in the user's code.
383
   * @throws InstanceNotFoundException if the specified bean is not
384
   *                                   registered with the server.
385
   * @throws OperationsException if any I/O error is thrown by the
386
   *                             deserialization process.
387
   * @throws SecurityException if a security manager exists and the
388
   *                           caller's permissions don't imply {@link
389
   *                           MBeanPermission(String,String,ObjectName,String)
390
   *                           <code>MBeanPermission(className, null, name,
391
   *                           "getClassLoaderFor")</code>
392
   */
393
  ObjectInputStream deserialize(ObjectName name, byte[] data)
394
    throws InstanceNotFoundException, OperationsException;
395
 
396
  /**
397
   * Deserializes a byte array using the same class loader for its context
398
   * as was used to load the given class.  This class loader is obtained by
399
   * loading the specified class using the {@link
400
   * javax.management.loading.ClassLoaderRepository Class Loader Repository}
401
   * and then using the class loader of the resulting {@link Class} instance.
402
   *
403
   * @param name the name of the class which should be loaded to obtain the
404
   *             class loader.
405
   * @param data the byte array to be deserialized.
406
   * @return the deserialized object stream.
407
   * @deprecated {@link #getClassLoaderRepository} should be used
408
   *             to obtain the class loading repository, which can then
409
   *             be used to obtain the {@link Class} instance and deserialize
410
   *             the array using its class loader.
411
   * @throws OperationsException if any I/O error is thrown by the
412
   *                             deserialization process.
413
   * @throws ReflectionException if an error occurs in obtaining the
414
   *                             {@link Class} instance.
415
   * @throws SecurityException if a security manager exists and the
416
   *                           caller's permissions don't imply {@link
417
   *                           MBeanPermission(String,String,ObjectName,String)
418
   *                           <code>MBeanPermission(null, null, null,
419
   *                           "getClassLoaderRepository")</code>
420
   */
421
  ObjectInputStream deserialize(String name, byte[] data)
422
    throws OperationsException, ReflectionException;
423
 
424
  /**
425
   * Deserializes a byte array using the same class loader for its context
426
   * as was used to load the given class.  The name of the class loader to
427
   * be used is supplied, and may be <code>null</code> if the server's
428
   * class loader should be used instead.
429
   *
430
   * @param name the name of the class which should be loaded to obtain the
431
   *             class loader.
432
   * @param loader the name of the class loader to use, or <code>null</code>
433
   *               if the class loader of the server should be used.
434
   * @param data the byte array to be deserialized.
435
   * @return the deserialized object stream.
436
   * @deprecated {@link #getClassLoader(ObjectName} can be used to obtain
437
   *              the named class loader and deserialize the array.
438
   * @throws InstanceNotFoundException if the specified class loader is not
439
   *                                   registered with the server.
440
   * @throws OperationsException if any I/O error is thrown by the
441
   *                             deserialization process.
442
   * @throws ReflectionException if an error occurs in obtaining the
443
   *                             {@link Class} instance.
444
   * @throws SecurityException if a security manager exists and the
445
   *                           caller's permissions don't imply {@link
446
   *                           MBeanPermission(String,String,ObjectName,String)
447
   *                           <code>MBeanPermission(className, null, loader,
448
   *                           "getClassLoader")</code>
449
   */
450
  ObjectInputStream deserialize(String name, ObjectName loader, byte[] data)
451
    throws InstanceNotFoundException, ReflectionException,
452
           OperationsException;
453
 
454
  /**
455
   * Returns the value of the supplied attribute from the specified
456
   * management bean.
457
   *
458
   * @param bean the bean to retrieve the value from.
459
   * @param name the name of the attribute to retrieve.
460
   * @return the value of the attribute.
461
   * @throws AttributeNotFoundException if the attribute could not be
462
   *                                    accessed from the bean.
463
   * @throws MBeanException if the management bean's accessor throws
464
   *                        an exception.
465
   * @throws InstanceNotFoundException if the bean can not be found.
466
   * @throws ReflectionException if an exception was thrown in trying
467
   *                             to invoke the bean's accessor.
468
   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
469
   *                                    is thrown by the server due to a
470
   *                                    <code>null</code> bean or attribute
471
   *                                    name.
472
   * @throws SecurityException if a security manager exists and the
473
   *                           caller's permissions don't imply {@link
474
   *                           MBeanPermission(String,String,ObjectName,String)
475
   *                           <code>MBeanPermission(className, name, bean,
476
   *                           "getAttribute")</code>}.
477
   * @see DynamicMBean#getAttribute(String)
478
   */
479
  Object getAttribute(ObjectName bean, String name)
480
    throws MBeanException, AttributeNotFoundException,
481
           InstanceNotFoundException, ReflectionException;
482
 
483
  /**
484
   * Returns the values of the named attributes from the specified
485
   * management bean.
486
   *
487
   * @param bean the bean to retrieve the value from.
488
   * @param names the names of the attributes to retrieve.
489
   * @return the values of the attributes.
490
   * @throws InstanceNotFoundException if the bean can not be found.
491
   * @throws ReflectionException if an exception was thrown in trying
492
   *                             to invoke the bean's accessor.
493
   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
494
   *                                    is thrown by the server due to a
495
   *                                    <code>null</code> bean or attribute
496
   *                                    name.
497
   * @throws SecurityException if a security manager exists and the
498
   *                           caller's permissions don't imply {@link
499
   *                           MBeanPermission(String,String,ObjectName,String)
500
   *                           <code>MBeanPermission(className, null, bean,
501
   *                           "getAttribute")</code>}.  Additionally,
502
   *                           for an attribute name, <code>n</code>, the
503
   *                           caller's permission must imply {@link
504
   *                           MBeanPermission(String,String,ObjectName,String)
505
   *                           <code>MBeanPermission(className, n, bean,
506
   *                           "getAttribute")</code>} or that attribute will
507
   *                           not be included.
508
   *
509
   * @see DynamicMBean#getAttributes(String[])
510
   */
511
  AttributeList getAttributes(ObjectName bean, String[] names)
512
    throws InstanceNotFoundException, ReflectionException;
513
 
514
  /**
515
   * Returns the specified class loader.  If the specified value is
516
   * <code>null</code>, then the class loader of the server will be
517
   * returned.  If <code>l</code> is the requested class loader,
518
   * and <code>r</code> is the actual class loader returned, then
519
   * either <code>l</code> and <code>r</code> will be identical,
520
   * or they will at least return the same class from
521
   * {@link ClassLoader#loadClass(String)} for any given string.
522
   * They may not be identical due to one or the other
523
   * being wrapped in another class loader (e.g. for security).
524
   *
525
   * @param name the name of the class loader to return.
526
   * @return the class loader.
527
   * @throws InstanceNotFoundException if the class loader can not
528
   *                                   be found.
529
   * @throws SecurityException if a security manager exists and the
530
   *                           caller's permissions don't imply {@link
531
   *                           MBeanPermission(String,String,ObjectName,String)
532
   *                           <code>MBeanPermission(className, null, name,
533
   *                           "getClassLoader")</code>
534
   */
535
  ClassLoader getClassLoader(ObjectName name)
536
    throws InstanceNotFoundException;
537
 
538
  /**
539
   * Returns the class loader of the specified management bean.  If
540
   * <code>l</code> is the requested class loader, and <code>r</code>
541
   * is the actual class loader returned, then either <code>l</code>
542
   * and <code>r</code> will be identical, or they will at least
543
   * return the same class from {@link ClassLoader#loadClass(String)}
544
   * for any given string.  They may not be identical due to one or
545
   * the other being wrapped in another class loader (e.g. for
546
   * security).
547
   *
548
   * @param name the name of the bean whose class loader should be
549
   *             returned.
550
   * @return the class loader.
551
   * @throws InstanceNotFoundException if the bean is not registered
552
   *                                   with the server.
553
   * @throws SecurityException if a security manager exists and the
554
   *                           caller's permissions don't imply {@link
555
   *                           MBeanPermission(String,String,ObjectName,String)
556
   *                           <code>MBeanPermission(className, null, name,
557
   *                           "getClassLoaderFor")</code>
558
   */
559
  ClassLoader getClassLoaderFor(ObjectName name)
560
    throws InstanceNotFoundException;
561
 
562
  /**
563
   * Returns the class loader repository used by this server.
564
   *
565
   * @return the class loader repository.
566
   * @throws SecurityException if a security manager exists and the
567
   *                           caller's permissions don't imply {@link
568
   *                           MBeanPermission(String,String,ObjectName,String)
569
   *                           <code>MBeanPermission(null, null, null,
570
   *                           "getClassLoaderRepository")</code>
571
   */
572
  ClassLoaderRepository getClassLoaderRepository();
573
 
574
  /**
575
   * Returns the default domain this server applies to beans that have
576
   * no specified domain.
577
   *
578
   * @return the default domain.
579
   */
580
  String getDefaultDomain();
581
 
582
  /**
583
   * Returns an array containing all the domains used by beans registered
584
   * with this server.  The ordering of the array is undefined.
585
   *
586
   * @return the list of domains.
587
   * @throws SecurityException if a security manager exists and the
588
   *                           caller's permissions don't imply {@link
589
   *                           MBeanPermission(String,String,ObjectName,String)
590
   *                           <code>MBeanPermission(null, null, name,
591
   *                           "getDomains")</code>}.  Additionally,
592
   *                           for an domain, <code>d</code>, the
593
   *                           caller's permission must imply {@link
594
   *                           MBeanPermission(String,String,ObjectName,String)
595
   *                           <code>MBeanPermission(null, null,
596
   *                           new ObjectName("d:x=x"), "getDomains")</code>}
597
   *                           or that domain will not be included.  Note
598
   *                           that "x=x" is an arbitrary key-value pair
599
   *                           provided to satisfy the constructor.
600
   * @see ObjectName#getDomain()
601
   */
602
  String[] getDomains();
603
 
604
  /**
605
   * Returns the number of management beans registered with this server.
606
   * This may be less than the real number if the caller's access is
607
   * restricted.
608
   *
609
   * @return the number of registered beans.
610
   */
611
  Integer getMBeanCount();
612
 
613
  /**
614
   * Returns information on the given management bean.
615
   *
616
   * @param name the name of the management bean.
617
   * @return an instance of {@link MBeanInfo} for the bean.
618
   * @throws IntrospectionException if an exception occurs in examining
619
   *                                the bean.
620
   * @throws InstanceNotFoundException if the bean can not be found.
621
   * @throws ReflectionException if an exception occurs when trying
622
   *                             to invoke {@link DynamicMBean#getMBeanInfo()}
623
   *                             on the bean.
624
   * @throws SecurityException if a security manager exists and the
625
   *                           caller's permissions don't imply {@link
626
   *                           MBeanPermission(String,String,ObjectName,String)
627
   *                           <code>MBeanPermission(className, null, name,
628
   *                           "getMBeanInfo")</code>}.
629
   * @see DynamicMBean#getMBeanInfo()
630
   */
631
  MBeanInfo getMBeanInfo(ObjectName name)
632
    throws InstanceNotFoundException, IntrospectionException,
633
           ReflectionException;
634
 
635
  /**
636
   * Returns the {@link ObjectInstance} created for the specified
637
   * management bean on registration.
638
   *
639
   * @param name the name of the bean.
640
   * @return the corresponding {@link ObjectInstance} instance.
641
   * @throws InstanceNotFoundException if the bean can not be found.
642
   * @throws SecurityException if a security manager exists and the
643
   *                           caller's permissions don't imply {@link
644
   *                           MBeanPermission(String,String,ObjectName,String)
645
   *                           <code>MBeanPermission(className, null, name,
646
   *                           "getObjectInstance")</code>
647
   * @see #createMBean(String, ObjectName)
648
   */
649
  ObjectInstance getObjectInstance(ObjectName name)
650
    throws InstanceNotFoundException;
651
 
652
  /**
653
   * <p>
654
   * Creates an instance of the specified class using the list of
655
   * class loaders from the {@link
656
   * javax.management.loading.ClassLoaderRepository Class Loader
657
   * Repository}.  The class should have a public constructor
658
   * with no arguments.  A reference to the new instance is returned,
659
   * but the instance is not yet registered with the server.
660
   * </p>
661
   * <p>
662
   * This method is equivalent to calling {@link
663
   * #instantiate(String, Object[], String[])
664
   * <code>instantiate(name, (Object[]) null, (String[]) null)</code>}
665
   * with <code>null</code> parameters and signature.
666
   * </p>
667
   *
668
   * @param name the name of the class of bean to be instantiated.
669
   * @return an instance of the given class.
670
   * @throws ReflectionException if an exception is thrown during
671
   *                             loading the class or calling the
672
   *                             constructor.
673
   * @throws MBeanException if the constructor throws an exception.
674
   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
675
   *                                    is thrown by the server due to a
676
   *                                    <code>null</code> name.
677
   * @throws SecurityException if a security manager exists and the
678
   *                           caller's permissions don't imply {@link
679
   *                           MBeanPermission(String,String,ObjectName,String)
680
   *                           <code>MBeanPermission(className, null, null,
681
   *                           "instantiate")</code>}.
682
   * @see #instantiate(String, Object[], String[])
683
   */
684
  Object instantiate(String name)
685
    throws ReflectionException, MBeanException;
686
 
687
  /**
688
   * Creates an instance of the specified class using the list of
689
   * class loaders from the {@link
690
   * javax.management.loading.ClassLoaderRepository Class Loader
691
   * Repository}.  The class should have a public constructor
692
   * matching the supplied signature.  A reference to the new
693
   * instance is returned, but the instance is not yet
694
   * registered with the server.
695
   *
696
   * @param name the name of the class of bean to be instantiated.
697
   * @param params the parameters for the constructor.
698
   * @param sig the signature of the constructor.
699
   * @return an instance of the given class.
700
   * @throws ReflectionException if an exception is thrown during
701
   *                             loading the class or calling the
702
   *                             constructor.
703
   * @throws MBeanException if the constructor throws an exception.
704
   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
705
   *                                    is thrown by the server due to a
706
   *                                    <code>null</code> name.
707
   * @throws SecurityException if a security manager exists and the
708
   *                           caller's permissions don't imply {@link
709
   *                           MBeanPermission(String,String,ObjectName,String)
710
   *                           <code>MBeanPermission(className, null, null,
711
   *                           "instantiate")</code>}.
712
   */
713
  Object instantiate(String name, Object[] params, String[] sig)
714
    throws ReflectionException, MBeanException;
715
 
716
  /**
717
   * <p>
718
   * Creates an instance of the specified class using the supplied
719
   * class loader.  If the class loader given is <code>null</code>,
720
   * then the class loader of the server will be used.  The class
721
   * should have a public constructor with no arguments.  A reference
722
   * to the new instance is returned, but the instance is not yet
723
   * registered with the server.
724
   * </p>
725
   * <p>
726
   * This method is equivalent to calling {@link
727
   * #instantiate(String, ObjectName, Object[], String[])
728
   * <code>instantiate(name, loaderName, (Object[]) null,
729
   * (String[]) null)</code>} with <code>null</code> parameters
730
   * and signature.
731
   * </p>
732
   *
733
   * @param name the name of the class of bean to be instantiated.
734
   * @param loaderName the name of the class loader to use.
735
   * @return an instance of the given class.
736
   * @throws InstanceNotFoundException if the class loader is not
737
   *                                   registered with the server.
738
   * @throws ReflectionException if an exception is thrown during
739
   *                             loading the class or calling the
740
   *                             constructor.
741
   * @throws MBeanException if the constructor throws an exception.
742
   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
743
   *                                    is thrown by the server due to a
744
   *                                    <code>null</code> name.
745
   * @throws SecurityException if a security manager exists and the
746
   *                           caller's permissions don't imply {@link
747
   *                           MBeanPermission(String,String,ObjectName,String)
748
   *                           <code>MBeanPermission(className, null, null,
749
   *                           "instantiate")</code>}.
750
   * @see #instantiate(String, Object[], String[])
751
   */
752
  Object instantiate(String name, ObjectName loaderName)
753
    throws InstanceNotFoundException, ReflectionException,
754
           MBeanException;
755
 
756
  /**
757
   * Creates an instance of the specified class using the supplied
758
   * class loader.  If the class loader given is <code>null</code>,
759
   * then the class loader of the server will be used.  The class
760
   * should have a public constructor matching the supplied
761
   * signature.  A reference to the new instance is returned,
762
   * but the instance is not yet registered with the server.
763
   *
764
   * @param name the name of the class of bean to be instantiated.
765
   * @param loaderName the name of the class loader to use.
766
   * @param params the parameters for the constructor.
767
   * @param sig the signature of the constructor.
768
   * @return an instance of the given class.
769
   * @throws InstanceNotFoundException if the class loader is not
770
   *                                   registered with the server.
771
   * @throws ReflectionException if an exception is thrown during
772
   *                             loading the class or calling the
773
   *                             constructor.
774
   * @throws MBeanException if the constructor throws an exception.
775
   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
776
   *                                    is thrown by the server due to a
777
   *                                    <code>null</code> name.
778
   * @throws SecurityException if a security manager exists and the
779
   *                           caller's permissions don't imply {@link
780
   *                           MBeanPermission(String,String,ObjectName,String)
781
   *                           <code>MBeanPermission(className, null, null,
782
   *                           "instantiate")</code>}.
783
   */
784
  Object instantiate(String name, ObjectName loaderName,
785
                     Object[] params, String[] sig)
786
    throws InstanceNotFoundException, ReflectionException,
787
           MBeanException;
788
 
789
  /**
790
   * Invokes the supplied operation on the specified management
791
   * bean.  The class objects specified in the signature are loaded
792
   * using the same class loader as was used for the management bean.
793
   *
794
   * @param bean the management bean whose operation should be invoked.
795
   * @param name the name of the operation to invoke.
796
   * @param params the parameters of the operation.
797
   * @param sig the signature of the operation.
798
   * @return the return value of the method.
799
   * @throws InstanceNotFoundException if the bean can not be found.
800
   * @throws MBeanException if the method invoked throws an exception.
801
   * @throws ReflectionException if an exception is thrown in invoking the
802
   *                             method.
803
   * @throws SecurityException if a security manager exists and the
804
   *                           caller's permissions don't imply {@link
805
   *                           MBeanPermission(String,String,ObjectName,String)
806
   *                           <code>MBeanPermission(className, name, bean,
807
   *                           "invoke")</code>}.
808
   * @see DynamicMBean#invoke(String, Object[], String[])
809
   */
810
  Object invoke(ObjectName bean, String name, Object[] params, String[] sig)
811
    throws InstanceNotFoundException, MBeanException,
812
           ReflectionException;
813
 
814
  /**
815
   * <p>
816
   * Returns true if the specified management bean is an instance
817
   * of the supplied class.
818
   * </p>
819
   * <p>
820
   * A bean, B, is an instance of a class, C, if either of the following
821
   * conditions holds:
822
   * </p>
823
   * <ul>
824
   * <li>The class name in B's {@link MBeanInfo} is equal to the supplied
825
   * name.</li>
826
   * <li>Both the class of B and C were loaded by the same class loader,
827
   * and B is assignable to C.</li>
828
   * </ul>
829
   *
830
   * @param name the name of the management bean.
831
   * @param className the name of the class to test if <code>name</code> is
832
   *                  an instance of.
833
   * @return true if either B is directly an instance of the named class,
834
   *         or B is assignable to the class, given that both it and B's
835
   *         current class were loaded using the same class loader.
836
   * @throws InstanceNotFoundException if the bean can not be found.
837
   * @throws SecurityException if a security manager exists and the
838
   *                           caller's permissions don't imply {@link
839
   *                           MBeanPermission(String,String,ObjectName,String)
840
   *                           <code>MBeanPermission(className, null, name,
841
   *                           "isInstanceOf")</code>
842
   */
843
  boolean isInstanceOf(ObjectName name, String className)
844
    throws InstanceNotFoundException;
845
 
846
  /**
847
   * Returns true if the specified management bean is registered with
848
   * the server.
849
   *
850
   * @param name the name of the management bean.
851
   * @return true if the bean is registered.
852
   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
853
   *                                    is thrown by the server due to a
854
   *                                    <code>null</code> bean name.
855
   */
856
  boolean isRegistered(ObjectName name);
857
 
858
  /**
859
   * <p>
860
   * Returns a set of {@link ObjectInstance}s matching the specified
861
   * criteria.  The full set of beans registered with the server
862
   * are passed through two filters:
863
   * </p>
864
   * <ol>
865
   * <li>Pattern matching is performed using the supplied
866
   * {@link ObjectName}.</li>
867
   * <li>The supplied query expression is applied.</li>
868
   * </ol>
869
   * <p>
870
   * If both the object name and the query expression are <code>null</code>,
871
   * or the object name has no domain and no key properties,
872
   * no filtering will be performed and all beans are returned.
873
   * </p>
874
   *
875
   * @param name an {@link ObjectName} to use as a filter.
876
   * @param query a query expression to apply to each of the beans that match
877
   *              the given object name.
878
   * @return a set of {@link ObjectInstance}s matching the filtered beans.
879
   * @throws SecurityException if a security manager exists and the
880
   *                           caller's permissions don't imply {@link
881
   *                           MBeanPermission(String,String,ObjectName,String)
882
   *                           <code>MBeanPermission(null, null, name,
883
   *                           "queryMBeans")</code>}.  Additionally,
884
   *                           for an bean, <code>b</code>, the
885
   *                           caller's permission must imply {@link
886
   *                           MBeanPermission(String,String,ObjectName,String)
887
   *                           <code>MBeanPermission(className, b, name,
888
   *                           "queryMBeans")</code>} or that bean will
889
   *                           not be included.  Such an exception may also
890
   *                           arise from the execution of the query, in which
891
   *                           case that particular bean will again be excluded.
892
   */
893
  Set<ObjectInstance> queryMBeans(ObjectName name, QueryExp query);
894
 
895
  /**
896
   * <p>
897
   * Returns a set of {@link ObjectName}s matching the specified
898
   * criteria.  The full set of beans registered with the server
899
   * are passed through two filters:
900
   * </p>
901
   * <ol>
902
   * <li>Pattern matching is performed using the supplied
903
   * {@link ObjectName}.</li>
904
   * <li>The supplied query expression is applied.</li>
905
   * </ol>
906
   * <p>
907
   * If both the object name and the query expression are <code>null</code>,
908
   * or the object name has no domain and no key properties,
909
   * no filtering will be performed and all beans are returned.
910
   * </p>
911
   *
912
   * @param name an {@link ObjectName} to use as a filter.
913
   * @param query a query expression to apply to each of the beans that match
914
   *              the given object name.
915
   * @return a set of {@link ObjectName}s matching the filtered beans.
916
   * @throws SecurityException if a security manager exists and the
917
   *                           caller's permissions don't imply {@link
918
   *                           MBeanPermission(String,String,ObjectName,String)
919
   *                           <code>MBeanPermission(null, null, name,
920
   *                           "queryNames")</code>}.  Additionally,
921
   *                           for an name, <code>n</code>, the
922
   *                           caller's permission must imply {@link
923
   *                           MBeanPermission(String,String,ObjectName,String)
924
   *                           <code>MBeanPermission(className, n, name,
925
   *                           "queryNames")</code>} or that name will
926
   *                           not be included.  Such an exception may also
927
   *                           arise from the execution of the query, in which
928
   *                           case that particular bean will again be excluded.
929
   *                           Note that these permissions are implied if the
930
   *                           <code>queryMBeans</code> permissions are available.
931
   */
932
  Set<ObjectName> queryNames(ObjectName name, QueryExp query);
933
 
934
  /**
935
   * Registers the supplied instance with the server, using the specified
936
   * {@link ObjectName}.  If the name given is <code>null</code>, then
937
   * the bean supplied is expected to implement the {@link MBeanRegistration}
938
   * interface and provide the name via the
939
   * {@link MBeanRegistration#preRegister preRegister} method
940
   * of this interface.
941
   *
942
   * @param obj the object to register with the server.
943
   * @param name the name under which to register the object,
944
   *             or <code>null</code> if the {@link MBeanRegistration}
945
   *             interface should be used.
946
   * @throws InstanceAlreadyExistsException if a matching instance
947
   *                                        already exists.
948
   * @throws MBeanRegistrationException if an exception occurs in
949
   *                                    calling the preRegister
950
   *                                    method.
951
   * @throws NotCompliantMBeanException if the created bean is not
952
   *                                    compliant with the JMX specification.
953
   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
954
   *                                    is thrown by the server due to a
955
   *                                    <code>null</code> object.
956
   * @throws SecurityException if a security manager exists and the
957
   *                           caller's permissions don't imply {@link
958
   *                           MBeanPermission(String,String,ObjectName,String)
959
   *                           <code>MBeanPermission(className, null, name,
960
   *                           "registerMBean")</code>}.  <code>className</code>
961
   *                           here corresponds to the result of
962
   *                           {@link MBeanInfo#getClassName()} for objects of
963
   *                           this class.  If this check succeeds, a check
964
   *                           is also made on its
965
   *                           {@link java.security.ProtectionDomain} to ensure
966
   *                           it implies {@link MBeanTrustPermission(String)
967
   *                           <code>MBeanTrustPermission("register")</code>}.
968
   *                           The use of the {@link MBeanRegistration} interface
969
   *                           results in another {@link MBeanPermission} check
970
   *                           being made on the returned {@link ObjectName}.
971
   */
972
  ObjectInstance registerMBean(Object obj, ObjectName name)
973
    throws InstanceAlreadyExistsException, MBeanRegistrationException,
974
           NotCompliantMBeanException;
975
 
976
  /**
977
   * Removes the specified listener from the list of recipients
978
   * of notifications from the supplied bean.  This includes all
979
   * combinations of filters and passback objects registered for
980
   * this listener.  For more specific removal of listeners, see
981
   * {@link #removeNotificationListener(ObjectName,
982
   * NotificationListener,NotificationFilter,Object)}
983
   *
984
   * @param name the name of the management bean from which the
985
   *             listener should be removed.
986
   * @param listener the listener to remove.
987
   * @throws InstanceNotFoundException if the bean can not be found.
988
   * @throws ListenerNotFoundException if the specified listener
989
   *                                   is not registered with the bean.
990
   * @throws SecurityException if a security manager exists and the
991
   *                           caller's permissions don't imply {@link
992
   *                           MBeanPermission(String,String,ObjectName,String)
993
   *                           <code>MBeanPermission(className, null, name,
994
   *                           "removeNotificationListener")</code>}.
995
   * @see #addNotificationListener(NotificationListener, NotificationFilter,
996
   *                               java.lang.Object)
997
   * @see NotificationBroadcaster#removeNotificationListener(NotificationListener)
998
   */
999
  void removeNotificationListener(ObjectName name,
1000
                                  NotificationListener listener)
1001
    throws InstanceNotFoundException, ListenerNotFoundException;
1002
 
1003
  /**
1004
   * Removes the specified listener from the list of recipients
1005
   * of notifications from the supplied bean.  Only the first instance with
1006
   * the supplied filter and passback object is removed.
1007
   * <code>null</code> is used as a valid value for these parameters,
1008
   * rather than as a way to remove all registration instances for
1009
   * the specified listener; for this behaviour instead, see
1010
   * {@link #removeNotificationListener(ObjectName, NotificationListener)}.
1011
   *
1012
   * @param name the name of the management bean from which the
1013
   *             listener should be removed.
1014
   * @param listener the listener to remove.
1015
   * @param filter the filter of the listener to remove.
1016
   * @param passback the passback object of the listener to remove.
1017
   * @throws InstanceNotFoundException if the bean can not be found.
1018
   * @throws ListenerNotFoundException if the specified listener
1019
   *                                   is not registered with the bean.
1020
   * @throws SecurityException if a security manager exists and the
1021
   *                           caller's permissions don't imply {@link
1022
   *                           MBeanPermission(String,String,ObjectName,String)
1023
   *                           <code>MBeanPermission(className, null, name,
1024
   *                           "removeNotificationListener")</code>}.
1025
   * @see #addNotificationListener(ObjectName, NotificationListener,
1026
   *                               NotificationFilter, Object)
1027
   * @see NotificationEmitter#removeNotificationListener(NotificationListener,
1028
   *                                                     NotificationFilter,
1029
   *                                                     Object)
1030
   */
1031
  void removeNotificationListener(ObjectName name,
1032
                                  NotificationListener listener,
1033
                                  NotificationFilter filter,
1034
                                  Object passback)
1035
    throws InstanceNotFoundException, ListenerNotFoundException;
1036
 
1037
  /**
1038
   * Removes the specified listener from the list of recipients
1039
   * of notifications from the supplied bean.  This includes all
1040
   * combinations of filters and passback objects registered for
1041
   * this listener.  For more specific removal of listeners, see
1042
   * {@link #removeNotificationListener(ObjectName,
1043
   * ObjectName,NotificationFilter,Object)}
1044
   *
1045
   * @param name the name of the management bean from which the
1046
   *             listener should be removed.
1047
   * @param listener the name of the listener to remove.
1048
   * @throws InstanceNotFoundException if a name doesn't match a registered
1049
   *                                   bean.
1050
   * @throws ListenerNotFoundException if the specified listener
1051
   *                                   is not registered with the bean.
1052
   * @throws SecurityException if a security manager exists and the
1053
   *                           caller's permissions don't imply {@link
1054
   *                           MBeanPermission(String,String,ObjectName,String)
1055
   *                           <code>MBeanPermission(className, null, name,
1056
   *                           "removeNotificationListener")</code>}.
1057
   * @see #addNotificationListener(NotificationListener, NotificationFilter,
1058
   *                               java.lang.Object)
1059
   * @see NotificationBroadcaster#removeNotificationListener(NotificationListener)
1060
   */
1061
  void removeNotificationListener(ObjectName name, ObjectName listener)
1062
    throws InstanceNotFoundException, ListenerNotFoundException;
1063
 
1064
  /**
1065
   * Removes the specified listener from the list of recipients
1066
   * of notifications from the supplied bean.  Only the first instance with
1067
   * the supplied filter and passback object is removed.
1068
   * <code>null</code> is used as a valid value for these parameters,
1069
   * rather than as a way to remove all registration instances for
1070
   * the specified listener; for this behaviour instead, see
1071
   * {@link #removeNotificationListener(ObjectName, ObjectName)}.
1072
   *
1073
   * @param name the name of the management bean from which the
1074
   *             listener should be removed.
1075
   * @param listener the name of the listener to remove.
1076
   * @param filter the filter of the listener to remove.
1077
   * @param passback the passback object of the listener to remove.
1078
   * @throws InstanceNotFoundException if a name doesn't match a registered
1079
   *                                   bean.
1080
   * @throws ListenerNotFoundException if the specified listener
1081
   *                                   is not registered with the bean.
1082
   * @throws SecurityException if a security manager exists and the
1083
   *                           caller's permissions don't imply {@link
1084
   *                           MBeanPermission(String,String,ObjectName,String)
1085
   *                           <code>MBeanPermission(className, null, name,
1086
   *                           "removeNotificationListener")</code>}.
1087
   * @see #addNotificationListener(ObjectName, NotificationListener,
1088
   *                               NotificationFilter, Object)
1089
   * @see NotificationEmitter#removeNotificationListener(NotificationListener,
1090
   *                                                     NotificationFilter,
1091
   *                                                     Object)
1092
   */
1093
  void removeNotificationListener(ObjectName name,
1094
                                  ObjectName listener,
1095
                                  NotificationFilter filter,
1096
                                  Object passback)
1097
    throws InstanceNotFoundException, ListenerNotFoundException;
1098
 
1099
  /**
1100
   * Sets the value of the specified attribute of the supplied
1101
   * management bean.
1102
   *
1103
   * @param name the name of the management bean.
1104
   * @param attribute the attribute to set.
1105
   * @throws InstanceNotFoundException if the bean can not be found.
1106
   * @throws AttributeNotFoundException if the attribute does not
1107
   *                                    correspond to an attribute
1108
   *                                    of the bean.
1109
   * @throws InvalidAttributeValueException if the value is invalid
1110
   *                                        for this particular
1111
   *                                        attribute of the bean.
1112
   * @throws MBeanException if setting the attribute causes
1113
   *                        the bean to throw an exception (which
1114
   *                        becomes the cause of this exception).
1115
   * @throws ReflectionException if an exception occurred in trying
1116
   *                             to use the reflection interface
1117
   *                             to lookup the attribute.  The
1118
   *                             thrown exception is the cause of
1119
   *                             this exception.
1120
   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
1121
   *                                    is thrown by the server due to a
1122
   *                                    <code>null</code> bean or attribute
1123
   *                                    name.
1124
   * @throws SecurityException if a security manager exists and the
1125
   *                           caller's permissions don't imply {@link
1126
   *                           MBeanPermission(String,String,ObjectName,String)
1127
   *                           <code>MBeanPermission(className, name, bean,
1128
   *                           "setAttribute")</code>}.
1129
   * @see #getAttribute(ObjectName, String)
1130
   * @see DynamicMBean#setAttribute(Attribute)
1131
   */
1132
  void setAttribute(ObjectName name, Attribute attribute)
1133
    throws InstanceNotFoundException, AttributeNotFoundException,
1134
           InvalidAttributeValueException, MBeanException,
1135
           ReflectionException;
1136
 
1137
  /**
1138
   * Sets the value of each of the specified attributes
1139
   * of the supplied management bean to that specified by
1140
   * the {@link Attribute} object.  The returned list contains
1141
   * the attributes that were set and their new values.
1142
   *
1143
   * @param name the name of the management bean.
1144
   * @param attributes the attributes to set.
1145
   * @return a list of the changed attributes.
1146
   * @throws InstanceNotFoundException if the bean can not be found.
1147
   * @throws ReflectionException if an exception occurred in trying
1148
   *                             to use the reflection interface
1149
   *                             to lookup the attribute.  The
1150
   *                             thrown exception is the cause of
1151
   *                             this exception.
1152
   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
1153
   *                                    is thrown by the server due to a
1154
   *                                    <code>null</code> bean or attribute
1155
   *                                    list.
1156
   * @throws SecurityException if a security manager exists and the
1157
   *                           caller's permissions don't imply {@link
1158
   *                           MBeanPermission(String,String,ObjectName,String)
1159
   *                           <code>MBeanPermission(className, null, bean,
1160
   *                           "setAttribute")</code>}.  Additionally,
1161
   *                           for an attribute name, <code>n</code>, the
1162
   *                           caller's permission must imply {@link
1163
   *                           MBeanPermission(String,String,ObjectName,String)
1164
   *                           <code>MBeanPermission(className, n, bean,
1165
   *                           "setAttribute")</code>} or that attribute will
1166
   *                           not be included.
1167
   * @see #getAttributes(ObjectName, String[])
1168
   * @see DynamicMBean#setAttributes(AttributeList)
1169
   */
1170
  AttributeList setAttributes(ObjectName name, AttributeList attributes)
1171
    throws InstanceNotFoundException, ReflectionException;
1172
 
1173
  /**
1174
   * Unregisters the specified management bean.  Following this operation,
1175
   * the bean instance is no longer accessible from the server via this
1176
   * name.  Prior to unregistering the bean, the
1177
   * {@link MBeanRegistration#preDeregister()} method will be called if
1178
   * the bean implements the {@link MBeanRegistration} interface.
1179
   *
1180
   * @param name the name of the management bean.
1181
   * @throws InstanceNotFoundException if the bean can not be found.
1182
   * @throws MBeanRegistrationException if an exception occurs in
1183
   *                                    calling the preDeregister
1184
   *                                    method.
1185
   * @throws RuntimeOperationsException if an {@link IllegalArgumentException}
1186
   *                                    is thrown by the server due to a
1187
   *                                    <code>null</code> bean name or a
1188
   *                                    request being made to unregister the
1189
   *                                    {@link MBeanServerDelegate} bean.
1190
   * @throws SecurityException if a security manager exists and the
1191
   *                           caller's permissions don't imply {@link
1192
   *                           MBeanPermission(String,String,ObjectName,String)
1193
   *                           <code>MBeanPermission(className, null, name,
1194
   *                           "unregisterMBean")</code>}.
1195
   */
1196
  void unregisterMBean(ObjectName name)
1197
    throws InstanceNotFoundException, MBeanRegistrationException;
1198
 
1199
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.