external-software/github_OpenIdentityPlatform_OpenDJ.git

			@@ -24,11 +24,11 @@
			* Copyright 2006-2008 Sun Microsystems, Inc.
			* Portions Copyright 2015 ForgeRock AS
			*/

			package org.opends.server.protocols.jmx;

			import java.io.IOException;
			import java.util.Map;

			import javax.management.ListenerNotFoundException;
			import javax.management.MBeanServerConnection;
			import javax.management.NotificationFilter;
			@@ -58,11 +58,6 @@
			/** The JMX Service URL. */
			private JMXServiceURL serviceURL;

			/** The host to connect to. */
			private String serverHostname;



			/**
			* Creates a connector client for the connector server at the
			* given host and port. The resultant client is not connected until its
			@@ -80,7 +75,6 @@
			*
			* @exception IOException if the connector client cannot be made
			* because of a communication problem.
			*
			*/
			public OpendsJmxConnector(String serverHostname, int serverPort,
			Map<String,Object> environment) throws IOException
			@@ -90,178 +84,57 @@
			+ "/org.opends.server.protocols.jmx.client-unknown");

			this.jmxc = JMXConnectorFactory.newJMXConnector(serviceURL, environment);
			this.serverHostname = serverHostname;
			this.environment = environment ;
			}
			// /**
			// * Sets this connector's connection environment.
			// *
			// * @param environment the new connection env
			// */
			// public void setConnectionEnv(Map connectionEnv)
			// {
			// this.environment = environment;
			// }

			/**
			* Returns the connection environment.
			*
			* @return Map the connection environment used by new connections
			*/
			public Map getConnectionEnv()
			public Map<String, Object> getConnectionEnv()
			{
			return environment;
			}

			/**
			* Establishes the connection to the connector server. This method is
			* equivalent to connect(null).
			*
			* @throws IOException
			* if the connection could not be made because of a communication
			* problem.
			* @throws SecurityException
			* if the connection could not be made for security reasons.
			*/
			/** {@inheritDoc} */
			@Override
			public void connect() throws IOException, SecurityException
			{
			connect(null);
			}

			/**
			* Establishes the connection to the connector server. If connect has
			* already been called successfully on this object, calling it again has
			* no effect. If, however, close() was called after connect, the new
			* connect will throw an IOException. Otherwise, either connect has never
			* been called on this object, or it has been called but produced an
			* exception. Then calling connect will attempt to establish a connection
			* to the connector server.
			*
			* @param env
			* the properties of the connection. Properties in this map
			* override properties in the map specified when the JMXConnector
			* was created, if any. This parameter can be null, which is
			* equivalent to an empty map.
			* @throws IOException
			* if the connection could not be made because of a communication
			* problem.
			* @throws SecurityException -
			* if the connection could not be made for security reasons.
			*/
			/** {@inheritDoc} */
			@Override
			public void connect(Map<String,?> env) throws IOException, SecurityException
			{
			jmxc.connect(env);
			}

			/**
			* Returns an MBeanServerConnection object representing a remote MBean
			* server. For a given JMXConnector, two successful calls to this method
			* will usually return the same MBeanServerConnection object, though this
			* is not required. For each method in the returned
			* MBeanServerConnection, calling the method causes the corresponding
			* method to be called in the remote MBean server. The value returned by
			* the MBean server method is the value returned to the client. If the
			* MBean server method produces an Exception, the same Exception is seen
			* by the client. If the MBean server method, or the attempt to call it,
			* produces an Error, the Error is wrapped in a JMXServerErrorException,
			* which is seen by the client. Calling this method is equivalent to
			* calling getMBeanServerConnection(null) meaning that no delegation
			* subject is specified and that all the operations called on the
			* MBeanServerConnection must use the authenticated subject, if any.
			*
			* @return an object that implements the MBeanServerConnection interface
			* by forwarding its methods to the remote MBean server.
			* @throws IOException -
			* if a valid MBeanServerConnection cannot be created, for
			* instance because the connection to the remote MBean server has
			* not yet been established (with the connect method), or it has
			* been closed, or it has broken.
			*/
			/** {@inheritDoc} */
			@Override
			public MBeanServerConnection getMBeanServerConnection() throws IOException
			{
			return jmxc.getMBeanServerConnection();
			}

			/**
			* Returns an MBeanServerConnection object representing a remote MBean
			* server on which operations are performed on behalf of the supplied
			* delegation subject. For a given JMXConnector and Subject, two
			* successful calls to this method will usually return the same
			* MBeanServerConnection object, though this is not required. For each
			* method in the returned MBeanServerConnection, calling the method
			* causes the corresponding method to be called in the remote MBean
			* server on behalf of the given delegation subject instead of the
			* authenticated subject. The value returned by the MBean server method
			* is the value returned to the client. If the MBean server method
			* produces an Exception, the same Exception is seen by the client. If
			* the MBean server method, or the attempt to call it, produces an Error,
			* the Error is wrapped in a JMXServerErrorException, which is seen by
			* the client.
			*
			* @param delegationSubject
			* the Subject on behalf of which requests will be performed. Can
			* be null, in which case requests will be performed on behalf of
			* the authenticated Subject, if any.
			* @return an object that implements the MBeanServerConnection interface
			* by forwarding its methods to the remote MBean server on behalf
			* of a given delegation subject.
			* @throws IOException
			* if a valid MBeanServerConnection cannot be created, for
			* instance because the connection to the remote MBean server has
			* not yet been established (with the connect method), or it has
			* been closed, or it has broken.
			*/
			/** {@inheritDoc} */
			@Override
			public MBeanServerConnection getMBeanServerConnection(
			Subject delegationSubject) throws IOException
			{
			return jmxc.getMBeanServerConnection(delegationSubject);
			}

			/**
			* Closes the client connection to its server. Any ongoing or new request
			* using the MBeanServerConnection returned by getMBeanServerConnection()
			* will get an IOException. If close has already been called successfully
			* on this object, calling it again has no effect. If close has never
			* been called, or if it was called but produced an exception, an attempt
			* will be made to close the connection. This attempt can succeed, in
			* which case close will return normally, or it can generate an
			* exception. Closing a connection is a potentially slow operation. For
			* example, if the server has crashed, the close operation might have to
			* wait for a network protocol timeout. Callers that do not want to block
			* in a close operation should do it in a separate thread.
			*
			* @throws IOException
			* if the connection cannot be closed cleanly. If this exception
			* is thrown, it is not known whether the server end of the
			* connection has been cleanly closed.
			*/
			/** {@inheritDoc} */
			@Override
			public void close() throws IOException
			{
			jmxc.close();
			}

			/**
			* Adds a listener to be informed of changes in connection status. The
			* listener will receive notifications of type JMXConnectionNotification.
			* An implementation can send other types of notifications too. Any
			* number of listeners can be added with this method. The same listener
			* can be added more than once with the same or different values for the
			* filter and handback. There is no special treatment of a duplicate
			* entry. For example, if a listener is registered twice with no filter,
			* then its handleNotification method will be called twice for each
			* notification.
			*
			* @param listener
			* a listener to receive connection status notifications.
			* @param filter
			* a filter to select which notifications are to be delivered to
			* the listener, or null if all notifications are to be delivered.
			* @param handback
			* an object to be given to the listener along with each
			* notification. Can be null.
			* @throws NullPointerException
			* if listener is null.
			*/
			/** {@inheritDoc} */
			@Override
			public void addConnectionNotificationListener(
			NotificationListener listener, NotificationFilter filter,
			Object handback) throws NullPointerException
			@@ -269,18 +142,8 @@
			jmxc.addConnectionNotificationListener(listener, filter, handback);
			}

			/**
			* Removes a listener from the list to be informed of changes in status.
			* The listener must previously have been added. If there is more than
			* one matching listener, all are removed.
			*
			* @param listener -
			* a listener to receive connection status notifications.
			* @throws NullPointerException
			* if listener is null.
			* @throws ListenerNotFoundException
			* if the listener is not registered with this JMXConnector.
			*/
			/** {@inheritDoc} */
			@Override
			public void removeConnectionNotificationListener(
			NotificationListener listener) throws ListenerNotFoundException,
			NullPointerException
			@@ -288,25 +151,8 @@
			jmxc.removeConnectionNotificationListener(listener);
			}

			/**
			* Removes a listener from the list to be informed of changes in status.
			* The listener must previously have been added with the same three
			* parameters. If there is more than one matching listener, only one is
			* removed.
			*
			* @param l
			* a listener to receive connection status notifications.
			* @param f
			* a filter to select which notifications are to be delivered to
			* the listener. Can be null. handback - an object to be given to
			* the listener along with each notification. Can be null.
			* @param handback
			* an object to be given to the listener along with each
			* notification. Can be null.
			* @throws ListenerNotFoundException
			* if the listener is not registered with this JMXConnector, or
			* is not registered with the given filter and handback.
			*/
			/** {@inheritDoc} */
			@Override
			public void removeConnectionNotificationListener(
			NotificationListener l, NotificationFilter f, Object handback)
			throws ListenerNotFoundException
			@@ -314,45 +160,10 @@
			jmxc.removeConnectionNotificationListener(l, f, handback);
			}

			/**
			* Gets this connection's ID from the connector server. For a given
			* connector server, every connection will have a unique id which does
			* not change during the lifetime of the connection.
			*
			* @return the unique ID of this connection. This is the same as the ID
			* that the connector server includes in its
			* JMXConnectionNotifications. The package description describes
			* the conventions for connection IDs.
			* @throws IOException
			* if the connection ID cannot be obtained, for instance because
			* the connection is closed or broken.
			*/
			/** {@inheritDoc} */
			@Override
			public String getConnectionId() throws IOException
			{
			return jmxc.getConnectionId();
			}

			/**
			* Update if necessary the credentials of the given map using
			* information coming from the map given when the connector was created.
			* This method is called from the connect method when it has received
			* a non null map holding potentially new credentials. It calls this
			* method BEFORE actually trying to connect to the server.
			*
			* @param Map given to the connect method
			*/
			private void updateCredentials(Map env) throws IOException
			{
			// credential to update ??
			if (!env.containsKey(JMXConnector.CREDENTIALS))
			{
			// NO : nothing to update
			return;
			}
			else
			{
			Object cred = env.get(JMXConnector.CREDENTIALS);
			environment.put(JMXConnector.CREDENTIALS, cred);
			}
			}
			}