mirror of https://github.com/OpenIdentityPlatform/OpenDJ.git

Jean-Noël Rouvignac
02.28.2016 77e0cf98df62ea367b263021fd67c58ed48a753c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
/*
 * The contents of this file are subject to the terms of the Common Development and
 * Distribution License (the License). You may not use this file except in compliance with the
 * License.
 *
 * You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the
 * specific language governing permission and limitations under the License.
 *
 * When distributing Covered Software, include this CDDL Header Notice in each file and include
 * the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL
 * Header, with the fields enclosed by brackets [] replaced by your own identifying
 * information: "Portions Copyright [year] [name of copyright owner]".
 *
 * Copyright 2006-2008 Sun Microsystems, Inc.
 * Portions Copyright 2015-2016 ForgeRock AS.
 */
package org.opends.server.api;
import org.forgerock.i18n.LocalizableMessage;
 
 
 
import java.util.List;
import javax.net.ssl.KeyManager;
 
import org.forgerock.opendj.server.config.server.KeyManagerProviderCfg;
import org.forgerock.opendj.config.server.ConfigException;
import org.opends.server.types.DirectoryException;
import org.opends.server.types.InitializationException;
 
 
 
/**
 * This class defines an API that may be used to obtain a set of
 * {@code javax.net.ssl.KeyManager} objects for use when performing
 * SSL communication.
 *
 * @param <T>
 *          The type of key manager provider configuration handled by
 *          this key manager provider implementation.
 */
@org.opends.server.types.PublicAPI(
     stability=org.opends.server.types.StabilityLevel.VOLATILE,
     mayInstantiate=false,
     mayExtend=true,
     mayInvoke=true)
public abstract class KeyManagerProvider
    <T extends KeyManagerProviderCfg>
{
  /**
   * Initializes this key manager provider based on the information in
   * the provided key manager provider configuration.
   *
   * @param configuration
   *          The key manager provider configuration that contains the
   *          information to use to initialize this key manager
   *          provider.
   * @throws ConfigException
   *           If an unrecoverable problem arises in the process of
   *           performing the initialization as a result of the server
   *           configuration.
   * @throws InitializationException
   *           If a problem occurs during initialization that is not
   *           related to the server configuration.
   */
  public abstract void initializeKeyManagerProvider(T configuration)
      throws ConfigException, InitializationException;
 
 
  /**
   *
   * Verifies that an alias is defined in the scope of this Key Manager.
   *
   * @param alias
   *          The alias to check.
   * @return true if the alias exists, false otherwise
   */
  public boolean containsKeyWithAlias(String alias)
  {
    return true;
  }
 
  /**
   *
   * Verifies that the keystore has at least one usable key.
   *
   * @return true if the keystore has at least one usable key, false otherwise
   */
  public boolean containsAtLeastOneKey()
  {
    return true;
  }
 
  /**
   * Indicates whether the provided configuration is acceptable for
   * this key manager provider.  It should be possible to call this
   * method on an uninitialized key manager provider instance in order
   * to determine whether the key manager provider would be able to
   * use the provided configuration.
   * <BR><BR>
   * Note that implementations which use a subclass of the provided
   * configuration class will likely need to cast the configuration
   * to the appropriate subclass type.
   *
   * @param  configuration        The key manager provider
   *                              configuration for which to make the
   *                              determination.
   * @param  unacceptableReasons  A list that may be used to hold the
   *                              reasons that the provided
   *                              configuration is not acceptable.
   *
   * @return  {@code true} if the provided configuration is acceptable
   *          for this key manager provider, or {@code false} if not.
   */
  public boolean isConfigurationAcceptable(
                      T configuration,
                      List<LocalizableMessage> unacceptableReasons)
  {
    // This default implementation does not perform any special
    // validation.  It should be overridden by key manager provider
    // implementations that wish to perform more detailed validation.
    return true;
  }
 
 
 
  /**
   * Performs any finalization that may be necessary for this key
   * manager provider.
   */
  public abstract void finalizeKeyManagerProvider();
 
 
 
  /**
   * Retrieves a set of {@code KeyManager} objects that may be used
   * for interactions requiring access to a key manager.
   *
   * @return  A set of {@code KeyManager} objects that may be used for
   *          interactions requiring access to a key manager.
   *
   * @throws  DirectoryException  If a problem occurs while attempting
   *                              to obtain the set of key managers.
   */
  public abstract KeyManager[] getKeyManagers()
         throws DirectoryException;
}