import org.jivesoftware.util.ModificationNotAllowedException; //导入依赖的package包/类
/**
 * Blocks an external component from connecting to the local server. If the component was
 * connected when the permission was revoked then the connection of the entity will be closed.
 *
 * @param subdomain the subdomain of the external component that is not allowed to connect.
 * @throws ModificationNotAllowedException if the operation was denied.
 */
public static void blockAccess(String subdomain) throws ModificationNotAllowedException {
    // Alert listeners about this event
    for (ExternalComponentManagerListener listener : listeners) {
        listener.componentBlocked(subdomain);
    }
    // Remove any previous configuration for this external component
    deleteConfigurationFromDB(getConfiguration(subdomain, false));
    // Update the database with the new revoked permission
    ExternalComponentConfiguration config = new ExternalComponentConfiguration(subdomain, false, Permission.blocked, null);
    addConfiguration(config);
    // Check if the component was connected and proceed to close the connection
    String domain = subdomain + "." + XMPPServer.getInstance().getServerInfo().getXMPPDomain();
    Session session = SessionManager.getInstance().getComponentSession(domain);
    if (session != null) {
        session.close();
    }
}
 

import org.jivesoftware.util.ModificationNotAllowedException; //导入依赖的package包/类
public static void updateComponentSecret(String subdomain, String secret) throws ModificationNotAllowedException {
    // Alert listeners about this event
    for (ExternalComponentManagerListener listener : listeners) {
        listener.componentSecretUpdated(subdomain, secret);
    }
    ExternalComponentConfiguration configuration = getConfiguration(subdomain, false);
    if (configuration != null) {
        configuration.setPermission(Permission.allowed);
        configuration.setSecret(secret);
        // Remove any previous configuration for this external component
        deleteConfigurationFromDB(configuration);
    }
    else {
        configuration = new ExternalComponentConfiguration(subdomain, false, Permission.allowed, secret);
    }
    addConfiguration(configuration);
}
 

import org.jivesoftware.util.ModificationNotAllowedException; //导入依赖的package包/类
/**
 * Sets the permission policy being used for new XMPP entities that are trying to
 * connect to the server. There are two types of policies: 1) blacklist: where any entity
 * is allowed to connect to the server except for those listed in the black list and
 * 2) whitelist: where only the entities listed in the white list are allowed to connect to
 * the server.
 *
 * @param policy the new PermissionPolicy to use.
 * @throws ModificationNotAllowedException if the operation was denied.
 */
public static void setPermissionPolicy(PermissionPolicy policy) throws ModificationNotAllowedException {
    // Alert listeners about this event
    for (ExternalComponentManagerListener listener : listeners) {
        listener.permissionPolicyChanged(policy);
    }
    JiveGlobals.setProperty("xmpp.component.permission", policy.toString());
    // Check if connected components can remain connected to the server
    for (ComponentSession session : SessionManager.getInstance().getComponentSessions()) {
        for (String domain : session.getExternalComponent().getSubdomains()) {
            if (!canAccess(domain)) {
                session.close();
                break;
            }
        }
    }
}
 

import org.jivesoftware.util.ModificationNotAllowedException; //导入依赖的package包/类
/**
 * Sets the shared secret for the Clearspace service we're connecting to.
 *
 * @param sharedSecret the password configured in Clearspace to authenticate Openfire.
 */
public void setSharedSecret(String sharedSecret) {
    // Set new password for external component
    ExternalComponentConfiguration configuration = new ExternalComponentConfiguration("clearspace", true,
            ExternalComponentConfiguration.Permission.allowed, sharedSecret);
    try {
        ExternalComponentManager.allowAccess(configuration);
    }
    catch (ModificationNotAllowedException e) {
        Log.warn("Failed to configure password for Clearspace", e);
    }

    // After updating the component information we can update the field, but not before.
    // If it is done before, OF won't be able to execute the updateSharedsecret webservice
    // since it would try with the new password.
    this.sharedSecret = sharedSecret;
    properties.put("clearspace.sharedSecret", sharedSecret);
}
 

import org.jivesoftware.util.ModificationNotAllowedException; //导入依赖的package包/类
/**
 * @deprecated Obtain and use the corresponding {@link org.jivesoftware.openfire.spi.ConnectionListener} instead.
 */
@Deprecated
public static void setServiceEnabled(boolean enabled) throws ModificationNotAllowedException {
    // Alert listeners about this event
    for (ExternalComponentManagerListener listener : listeners) {
        listener.serviceEnabled(enabled);
    }
    ConnectionManager connectionManager = XMPPServer.getInstance().getConnectionManager();
    connectionManager.enableComponentListener(enabled);
}
 

import org.jivesoftware.util.ModificationNotAllowedException; //导入依赖的package包/类
/**
 * @deprecated Obtain and use the corresponding {@link org.jivesoftware.openfire.spi.ConnectionListener} instead.
 */
@Deprecated
public static void setServicePort(int port) throws ModificationNotAllowedException {
    // Alert listeners about this event
    for (ExternalComponentManagerListener listener : listeners) {
        listener.portChanged(port);
    }
    ConnectionManager connectionManager = XMPPServer.getInstance().getConnectionManager();
    connectionManager.setComponentListenerPort(port);
}
 

import org.jivesoftware.util.ModificationNotAllowedException; //导入依赖的package包/类
/**
 * Allows an external component to connect to the local server with the specified configuration.
 *
 * @param configuration the configuration for the external component.
 * @throws ModificationNotAllowedException if the operation was denied.
 */
public static void allowAccess(ExternalComponentConfiguration configuration) throws ModificationNotAllowedException {
    // Alert listeners about this event
    for (ExternalComponentManagerListener listener : listeners) {
        listener.componentAllowed(configuration.getSubdomain(), configuration);
    }
    // Remove any previous configuration for this external component
    deleteConfigurationFromDB(configuration);
    // Update the database with the new granted permission and configuration
    configuration.setPermission(Permission.allowed);
    addConfiguration(configuration);
}
 

import org.jivesoftware.util.ModificationNotAllowedException; //导入依赖的package包/类
/**
 * Removes any existing defined permission and configuration for the specified
 * external component.
 *
 * @param subdomain the subdomain of the external component.
 * @throws ModificationNotAllowedException if the operation was denied.
 */
public static void deleteConfiguration(String subdomain) throws ModificationNotAllowedException {
    // Alert listeners about this event
    for (ExternalComponentManagerListener listener : listeners) {
        listener.componentConfigurationDeleted(subdomain);
    }

    // Proceed to delete the configuration of the component
    deleteConfigurationFromDB(getConfiguration(subdomain, false));
}
 

import org.jivesoftware.util.ModificationNotAllowedException; //导入依赖的package包/类
public static void setServiceEnabled(boolean enabled) throws ModificationNotAllowedException {
    // Alert listeners about this event
    for (ExternalComponentManagerListener listener : listeners) {
        listener.serviceEnabled(enabled);
    }
    ConnectionManager connectionManager = XMPPServer.getInstance().getConnectionManager();
    connectionManager.enableComponentListener(enabled);
}
 

import org.jivesoftware.util.ModificationNotAllowedException; //导入依赖的package包/类
public static void setServicePort(int port) throws ModificationNotAllowedException {
    // Alert listeners about this event
    for (ExternalComponentManagerListener listener : listeners) {
        listener.portChanged(port);
    }
    ConnectionManager connectionManager = XMPPServer.getInstance().getConnectionManager();
    connectionManager.setComponentListenerPort(port);
}
 

import org.jivesoftware.util.ModificationNotAllowedException; //导入依赖的package包/类
public void serviceEnabled(boolean enabled) throws ModificationNotAllowedException {
    // Do not let admins shutdown the external component service
    if (!enabled) {
        throw new ModificationNotAllowedException("Service cannot be disabled when integrated with Clearspace.");
    }
}
 

import org.jivesoftware.util.ModificationNotAllowedException; //导入依赖的package包/类
public void portChanged(int newPort) throws ModificationNotAllowedException {
    startClearspaceConfig();
}
 

import org.jivesoftware.util.ModificationNotAllowedException; //导入依赖的package包/类
public void defaultSecretChanged(String newSecret) throws ModificationNotAllowedException {
    // Do nothing
}
 

import org.jivesoftware.util.ModificationNotAllowedException; //导入依赖的package包/类
public void permissionPolicyChanged(ExternalComponentManager.PermissionPolicy newPolicy)
        throws ModificationNotAllowedException {
    // Do nothing
}
 

import org.jivesoftware.util.ModificationNotAllowedException; //导入依赖的package包/类
public void componentAllowed(String subdomain, ExternalComponentConfiguration configuration)
        throws ModificationNotAllowedException {
    if (subdomain.startsWith("clearspace")) {
        updateClearspaceSharedSecret(configuration.getSecret());
    }
}
 

import org.jivesoftware.util.ModificationNotAllowedException; //导入依赖的package包/类
public void componentBlocked(String subdomain) throws ModificationNotAllowedException {
    if (subdomain.startsWith("clearspace")) {
        throw new ModificationNotAllowedException("Communication with Clearspace cannot be blocked.");
    }
}
 

import org.jivesoftware.util.ModificationNotAllowedException; //导入依赖的package包/类
public void componentSecretUpdated(String subdomain, String newSecret) throws ModificationNotAllowedException {
    if (subdomain.startsWith("clearspace")) {
        updateClearspaceSharedSecret(newSecret);
    }
}
 

import org.jivesoftware.util.ModificationNotAllowedException; //导入依赖的package包/类
public void componentConfigurationDeleted(String subdomain) throws ModificationNotAllowedException {
    // Do not let admins delete configuration of Clearspace component
    if (subdomain.startsWith("clearspace")) {
        throw new ModificationNotAllowedException("Use 'Profile Settings' to change password.");
    }
}