001/*
002 * The contents of this file are subject to the terms of the Common Development and
003 * Distribution License (the License). You may not use this file except in compliance with the
004 * License.
005 *
006 * You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the
007 * specific language governing permission and limitations under the License.
008 *
009 * When distributing Covered Software, include this CDDL Header Notice in each file and include
010 * the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL
011 * Header, with the fields enclosed by brackets [] replaced by your own identifying
012 * information: "Portions Copyright [year] [name of copyright owner]".
013 *
014 * Copyright 2008 Sun Microsystems, Inc.
015 */
016package org.opends.server.admin.std.meta;
017
018
019
020import org.forgerock.opendj.ldap.DN;
021import org.opends.server.admin.AdministratorAction;
022import org.opends.server.admin.ClassPropertyDefinition;
023import org.opends.server.admin.client.AuthorizationException;
024import org.opends.server.admin.client.CommunicationException;
025import org.opends.server.admin.client.ConcurrentModificationException;
026import org.opends.server.admin.client.ManagedObject;
027import org.opends.server.admin.client.MissingMandatoryPropertiesException;
028import org.opends.server.admin.client.OperationRejectedException;
029import org.opends.server.admin.DefaultBehaviorProvider;
030import org.opends.server.admin.DefinedDefaultBehaviorProvider;
031import org.opends.server.admin.ManagedObjectAlreadyExistsException;
032import org.opends.server.admin.ManagedObjectDefinition;
033import org.opends.server.admin.PropertyOption;
034import org.opends.server.admin.PropertyProvider;
035import org.opends.server.admin.server.ConfigurationChangeListener;
036import org.opends.server.admin.server.ServerManagedObject;
037import org.opends.server.admin.SizePropertyDefinition;
038import org.opends.server.admin.std.client.SizeLimitLogRetentionPolicyCfgClient;
039import org.opends.server.admin.std.server.LogRetentionPolicyCfg;
040import org.opends.server.admin.std.server.SizeLimitLogRetentionPolicyCfg;
041import org.opends.server.admin.Tag;
042import org.opends.server.admin.UndefinedDefaultBehaviorProvider;
043
044
045
046/**
047 * An interface for querying the Size Limit Log Retention Policy
048 * managed object definition meta information.
049 * <p>
050 * Retention policy based on the amount of space taken by all the log
051 * files on disk.
052 */
053public final class SizeLimitLogRetentionPolicyCfgDefn extends ManagedObjectDefinition<SizeLimitLogRetentionPolicyCfgClient, SizeLimitLogRetentionPolicyCfg> {
054
055  // The singleton configuration definition instance.
056  private static final SizeLimitLogRetentionPolicyCfgDefn INSTANCE = new SizeLimitLogRetentionPolicyCfgDefn();
057
058
059
060  // The "disk-space-used" property definition.
061  private static final SizePropertyDefinition PD_DISK_SPACE_USED;
062
063
064
065  // The "java-class" property definition.
066  private static final ClassPropertyDefinition PD_JAVA_CLASS;
067
068
069
070  // Build the "disk-space-used" property definition.
071  static {
072      SizePropertyDefinition.Builder builder = SizePropertyDefinition.createBuilder(INSTANCE, "disk-space-used");
073      builder.setOption(PropertyOption.MANDATORY);
074      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "disk-space-used"));
075      builder.setDefaultBehaviorProvider(new UndefinedDefaultBehaviorProvider<Long>());
076      builder.setLowerLimit("1");
077      PD_DISK_SPACE_USED = builder.getInstance();
078      INSTANCE.registerPropertyDefinition(PD_DISK_SPACE_USED);
079  }
080
081
082
083  // Build the "java-class" property definition.
084  static {
085      ClassPropertyDefinition.Builder builder = ClassPropertyDefinition.createBuilder(INSTANCE, "java-class");
086      builder.setOption(PropertyOption.MANDATORY);
087      builder.setOption(PropertyOption.ADVANCED);
088      builder.setAdministratorAction(new AdministratorAction(AdministratorAction.Type.NONE, INSTANCE, "java-class"));
089      DefaultBehaviorProvider<String> provider = new DefinedDefaultBehaviorProvider<String>("org.opends.server.loggers.SizeBasedRetentionPolicy");
090      builder.setDefaultBehaviorProvider(provider);
091      builder.addInstanceOf("org.opends.server.loggers.RetentionPolicy");
092      PD_JAVA_CLASS = builder.getInstance();
093      INSTANCE.registerPropertyDefinition(PD_JAVA_CLASS);
094  }
095
096
097
098  // Register the tags associated with this managed object definition.
099  static {
100    INSTANCE.registerTag(Tag.valueOf("logging"));
101  }
102
103
104
105  /**
106   * Get the Size Limit Log Retention Policy configuration definition
107   * singleton.
108   *
109   * @return Returns the Size Limit Log Retention Policy configuration
110   *         definition singleton.
111   */
112  public static SizeLimitLogRetentionPolicyCfgDefn getInstance() {
113    return INSTANCE;
114  }
115
116
117
118  /**
119   * Private constructor.
120   */
121  private SizeLimitLogRetentionPolicyCfgDefn() {
122    super("size-limit-log-retention-policy", LogRetentionPolicyCfgDefn.getInstance());
123  }
124
125
126
127  /**
128   * {@inheritDoc}
129   */
130  public SizeLimitLogRetentionPolicyCfgClient createClientConfiguration(
131      ManagedObject<? extends SizeLimitLogRetentionPolicyCfgClient> impl) {
132    return new SizeLimitLogRetentionPolicyCfgClientImpl(impl);
133  }
134
135
136
137  /**
138   * {@inheritDoc}
139   */
140  public SizeLimitLogRetentionPolicyCfg createServerConfiguration(
141      ServerManagedObject<? extends SizeLimitLogRetentionPolicyCfg> impl) {
142    return new SizeLimitLogRetentionPolicyCfgServerImpl(impl);
143  }
144
145
146
147  /**
148   * {@inheritDoc}
149   */
150  public Class<SizeLimitLogRetentionPolicyCfg> getServerConfigurationClass() {
151    return SizeLimitLogRetentionPolicyCfg.class;
152  }
153
154
155
156  /**
157   * Get the "disk-space-used" property definition.
158   * <p>
159   * Specifies the maximum total disk space used by the log files.
160   *
161   * @return Returns the "disk-space-used" property definition.
162   */
163  public SizePropertyDefinition getDiskSpaceUsedPropertyDefinition() {
164    return PD_DISK_SPACE_USED;
165  }
166
167
168
169  /**
170   * Get the "java-class" property definition.
171   * <p>
172   * Specifies the fully-qualified name of the Java class that
173   * provides the Size Limit Log Retention Policy implementation.
174   *
175   * @return Returns the "java-class" property definition.
176   */
177  public ClassPropertyDefinition getJavaClassPropertyDefinition() {
178    return PD_JAVA_CLASS;
179  }
180
181
182
183  /**
184   * Managed object client implementation.
185   */
186  private static class SizeLimitLogRetentionPolicyCfgClientImpl implements
187    SizeLimitLogRetentionPolicyCfgClient {
188
189    // Private implementation.
190    private ManagedObject<? extends SizeLimitLogRetentionPolicyCfgClient> impl;
191
192
193
194    // Private constructor.
195    private SizeLimitLogRetentionPolicyCfgClientImpl(
196        ManagedObject<? extends SizeLimitLogRetentionPolicyCfgClient> impl) {
197      this.impl = impl;
198    }
199
200
201
202    /**
203     * {@inheritDoc}
204     */
205    public Long getDiskSpaceUsed() {
206      return impl.getPropertyValue(INSTANCE.getDiskSpaceUsedPropertyDefinition());
207    }
208
209
210
211    /**
212     * {@inheritDoc}
213     */
214    public void setDiskSpaceUsed(long value) {
215      impl.setPropertyValue(INSTANCE.getDiskSpaceUsedPropertyDefinition(), value);
216    }
217
218
219
220    /**
221     * {@inheritDoc}
222     */
223    public String getJavaClass() {
224      return impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
225    }
226
227
228
229    /**
230     * {@inheritDoc}
231     */
232    public void setJavaClass(String value) {
233      impl.setPropertyValue(INSTANCE.getJavaClassPropertyDefinition(), value);
234    }
235
236
237
238    /**
239     * {@inheritDoc}
240     */
241    public ManagedObjectDefinition<? extends SizeLimitLogRetentionPolicyCfgClient, ? extends SizeLimitLogRetentionPolicyCfg> definition() {
242      return INSTANCE;
243    }
244
245
246
247    /**
248     * {@inheritDoc}
249     */
250    public PropertyProvider properties() {
251      return impl;
252    }
253
254
255
256    /**
257     * {@inheritDoc}
258     */
259    public void commit() throws ManagedObjectAlreadyExistsException,
260        MissingMandatoryPropertiesException, ConcurrentModificationException,
261        OperationRejectedException, AuthorizationException,
262        CommunicationException {
263      impl.commit();
264    }
265
266
267
268    /** {@inheritDoc} */
269    public String toString() {
270      return impl.toString();
271    }
272  }
273
274
275
276  /**
277   * Managed object server implementation.
278   */
279  private static class SizeLimitLogRetentionPolicyCfgServerImpl implements
280    SizeLimitLogRetentionPolicyCfg {
281
282    // Private implementation.
283    private ServerManagedObject<? extends SizeLimitLogRetentionPolicyCfg> impl;
284
285    // The value of the "disk-space-used" property.
286    private final long pDiskSpaceUsed;
287
288    // The value of the "java-class" property.
289    private final String pJavaClass;
290
291
292
293    // Private constructor.
294    private SizeLimitLogRetentionPolicyCfgServerImpl(ServerManagedObject<? extends SizeLimitLogRetentionPolicyCfg> impl) {
295      this.impl = impl;
296      this.pDiskSpaceUsed = impl.getPropertyValue(INSTANCE.getDiskSpaceUsedPropertyDefinition());
297      this.pJavaClass = impl.getPropertyValue(INSTANCE.getJavaClassPropertyDefinition());
298    }
299
300
301
302    /**
303     * {@inheritDoc}
304     */
305    public void addSizeLimitChangeListener(
306        ConfigurationChangeListener<SizeLimitLogRetentionPolicyCfg> listener) {
307      impl.registerChangeListener(listener);
308    }
309
310
311
312    /**
313     * {@inheritDoc}
314     */
315    public void removeSizeLimitChangeListener(
316        ConfigurationChangeListener<SizeLimitLogRetentionPolicyCfg> listener) {
317      impl.deregisterChangeListener(listener);
318    }
319    /**
320     * {@inheritDoc}
321     */
322    public void addChangeListener(
323        ConfigurationChangeListener<LogRetentionPolicyCfg> listener) {
324      impl.registerChangeListener(listener);
325    }
326
327
328
329    /**
330     * {@inheritDoc}
331     */
332    public void removeChangeListener(
333        ConfigurationChangeListener<LogRetentionPolicyCfg> listener) {
334      impl.deregisterChangeListener(listener);
335    }
336
337
338
339    /**
340     * {@inheritDoc}
341     */
342    public long getDiskSpaceUsed() {
343      return pDiskSpaceUsed;
344    }
345
346
347
348    /**
349     * {@inheritDoc}
350     */
351    public String getJavaClass() {
352      return pJavaClass;
353    }
354
355
356
357    /**
358     * {@inheritDoc}
359     */
360    public Class<? extends SizeLimitLogRetentionPolicyCfg> configurationClass() {
361      return SizeLimitLogRetentionPolicyCfg.class;
362    }
363
364
365
366    /**
367     * {@inheritDoc}
368     */
369    public DN dn() {
370      return impl.getDN();
371    }
372
373
374
375    /** {@inheritDoc} */
376    public String toString() {
377      return impl.toString();
378    }
379  }
380}