com.unboundid.ldap.sdk.unboundidds.extensions.CollectSupportDataExtendedRequest Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of unboundid-ldapsdk Show documentation
Show all versions of unboundid-ldapsdk Show documentation
The UnboundID LDAP SDK for Java is a fast, comprehensive, and easy-to-use
Java API for communicating with LDAP directory servers and performing
related tasks like reading and writing LDIF, encoding and decoding data
using base64 and ASN.1 BER, and performing secure communication. This
package contains the Standard Edition of the LDAP SDK, which is a
complete, general-purpose library for communicating with LDAPv3 directory
servers.
The newest version!
/*
* Copyright 2020-2024 Ping Identity Corporation
* All Rights Reserved.
*/
/*
* Copyright 2020-2024 Ping Identity Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* Copyright (C) 2020-2024 Ping Identity Corporation
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License (GPLv2 only)
* or the terms of the GNU Lesser General Public License (LGPLv2.1 only)
* as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, see .
*/
package com.unboundid.ldap.sdk.unboundidds.extensions;
import java.util.ArrayList;
import java.util.List;
import com.unboundid.asn1.ASN1Boolean;
import com.unboundid.asn1.ASN1Element;
import com.unboundid.asn1.ASN1Enumerated;
import com.unboundid.asn1.ASN1Integer;
import com.unboundid.asn1.ASN1OctetString;
import com.unboundid.asn1.ASN1Sequence;
import com.unboundid.ldap.sdk.Control;
import com.unboundid.ldap.sdk.ExtendedRequest;
import com.unboundid.ldap.sdk.ExtendedResult;
import com.unboundid.ldap.sdk.IntermediateResponse;
import com.unboundid.ldap.sdk.IntermediateResponseListener;
import com.unboundid.ldap.sdk.LDAPException;
import com.unboundid.ldap.sdk.LDAPConnection;
import com.unboundid.ldap.sdk.LDAPRuntimeException;
import com.unboundid.ldap.sdk.ResultCode;
import com.unboundid.ldap.sdk.unboundidds.tasks.CollectSupportDataSecurityLevel;
import com.unboundid.util.Debug;
import com.unboundid.util.NotMutable;
import com.unboundid.util.NotNull;
import com.unboundid.util.Nullable;
import com.unboundid.util.StaticUtils;
import com.unboundid.util.ThreadSafety;
import com.unboundid.util.ThreadSafetyLevel;
import com.unboundid.util.Validator;
import static com.unboundid.ldap.sdk.unboundidds.extensions.ExtOpMessages.*;
/**
* This class provides an implementation of an extended request that may be used
* to invoke the collect-support data tool in a Ping Identity Directory Server
* and stream the output (using
* {@link CollectSupportDataOutputIntermediateResponse} messages) and the
* resulting support data archive (using
* {@link CollectSupportDataArchiveFragmentIntermediateResponse} messages)
* back to the client before the final
* {@link CollectSupportDataExtendedResult} response.
*
*
* NOTE: This class, and other classes within the
* {@code com.unboundid.ldap.sdk.unboundidds} package structure, are only
* supported for use against Ping Identity, UnboundID, and
* Nokia/Alcatel-Lucent 8661 server products. These classes provide support
* for proprietary functionality or for external specifications that are not
* considered stable or mature enough to be guaranteed to work in an
* interoperable way with other types of LDAP servers.
*
*
* The collect support data extended request has an OID of
* 1.3.6.1.4.1.30221.2.6.64 and a value with the following encoding:
*
*
* CollectSupportDataRequest ::= SEQUENCE {
* archiveFileName [0] OCTET STRING OPTIONAL,
* encryptionPassphrase [1] OCTET STRING OPTIONAL,
* includeExpensiveData [2] BOOLEAN DEFAULT FALSE,
* includeReplicationStateDump [3] BOOLEAN DEFAULT FALSE,
* includeBinaryFiles [4] BOOLEAN DEFAULT FALSE,
* includeExtensionSource [5] BOOLEAN DEFAULT FALSE,
* useSequentialMode [6] BOOLEAN DEFAULT FALSE,
* securityLevel [7] ENUMERATED {
* none (0),
* obscureSecrets (1),
* maximum (2),
* ... } DEFAULT obscureSecrets,
* jstackCount [8] INTEGER (0..MAX) DEFAULT 10,
* reportCount [9] INTEGER (0..MAX) DEFAULT 10,
* reportIntervalSeconds [10] INTEGER (1..MAX) DEFAULT 1,
* logCaptureWindow [11] CHOICE {
* toolDefault [0] NULL,
* durationMillis [1] INTEGER (0..MAX),
* timeWindow [2] SEQUENCE {
* startTime OCTET STRING,
* endTime OCTET STRING OPTIONAL },
* headAndTailSize [3] SEQUENCE {
* headSizeKB [0] INTEGER OPTIONAL,
* tailSizeKB [1] INTEGER OPTIONAL },
* ... } DEFAULT default,
* comment [12] OCTET STRING OPTIONAL,
* proxyToServer [13] SEQUENCE OF {
* address OCTET STRING,
* port INTEGER (1..65535),
* ... } OPTIONAL,
* maximumFragmentSizeBytes [1] INTEGER DEFAULT 1048576,
* ... }
*
*
* Because the tool output and the support data archive will be streamed back to
* the client using intermediate response messages, the request must be
* configured with an intermediate response listener to gain access to that
* information.
*
* @see CollectSupportDataExtendedResult
* @see CollectSupportDataOutputIntermediateResponse
* @see CollectSupportDataArchiveFragmentIntermediateResponse
* @see CollectSupportDataSecurityLevel
* @see CollectSupportDataLogCaptureWindow
*/
@NotMutable()
@ThreadSafety(level=ThreadSafetyLevel.COMPLETELY_THREADSAFE)
public final class CollectSupportDataExtendedRequest
extends ExtendedRequest
implements IntermediateResponseListener
{
/**
* The OID (1.3.6.1.4.1.30221.2.6.64) for the collect support data extended
* request.
*/
@NotNull public static final String COLLECT_SUPPORT_DATA_REQUEST_OID =
"1.3.6.1.4.1.30221.2.6.64";
/**
* The BER type for the request element that specifies the name to use for the
* archive file.
*/
private static final byte TYPE_ARCHIVE_FILE_NAME = (byte) 0x80;
/**
* The BER type for the request element that specifies the passphrase to use
* to encrypt the contents of the support data archive.
*/
static final byte TYPE_ENCRYPTION_PASSPHRASE = (byte) 0x81;
/**
* The BER type for the request element that indicates whether to include
* data that may be expensive to collect.
*/
private static final byte TYPE_INCLUDE_EXPENSIVE_DATA = (byte) 0x82;
/**
* The BER type for the request element that indicates whether to include a
* replication state dump.
*/
private static final byte TYPE_INCLUDE_REPLICATION_STATE_DUMP = (byte) 0x83;
/**
* The BER type for the request element that indicates whether to include
* binary files.
*/
private static final byte TYPE_INCLUDE_BINARY_FILES = (byte) 0x84;
/**
* The BER type for the request element that indicates whether to include
* extension source code.
*/
private static final byte TYPE_INCLUDE_EXTENSION_SOURCE = (byte) 0x85;
/**
* The BER type for the request element that indicates whether to collect
* information in sequential mode.
*/
private static final byte TYPE_USE_SEQUENTIAL_MODE = (byte) 0x86;
/**
* The BER type for the request element that specifies the security level.
*/
private static final byte TYPE_SECURITY_LEVEL = (byte) 0x87;
/**
* The BER type for the request element that specifies the number of jstack
* stack traces to include.
*/
private static final byte TYPE_JSTACK_COUNT = (byte) 0x88;
/**
* The BER type for the request element that specifies the number intervals
* to collect from interval-based sampling tools.
*/
private static final byte TYPE_REPORT_COUNT = (byte) 0x89;
/**
* The BER type for the request element that specifies the interval duration
* to use for interval-based sampling tools.
*/
private static final byte TYPE_REPORT_INTERVAL_SECONDS = (byte) 0x8A;
/**
* The BER type for the request element that specifies the log capture window
* for the request.
*/
private static final byte TYPE_LOG_CAPTURE_WINDOW = (byte) 0xAB;
/**
* The BER type for the request element that specifies a comment to include in
* the archive.
*/
private static final byte TYPE_COMMENT = (byte) 0x8C;
/**
* The BER type for the request element that specifies the address and port
* to which the request should be forwarded.
*/
private static final byte TYPE_PROXY_TO_SERVER = (byte) 0xAD;
/**
* The BER type for the request element that specifies the maximum archive
* fragment size.
*/
private static final byte TYPE_MAXIMUM_FRAGMENT_SIZE_BYTES = (byte) 0x8E;
/**
* The integer value for the {@link CollectSupportDataSecurityLevel#NONE}
* security level.
*/
private static final int SECURITY_LEVEL_VALUE_NONE = 0;
/**
* The integer value for the
* {@link CollectSupportDataSecurityLevel#OBSCURE_SECRETS} security level.
*/
private static final int SECURITY_LEVEL_VALUE_OBSCURE_SECRETS = 1;
/**
* The integer value for the {@link CollectSupportDataSecurityLevel#MAXIMUM}
* security level.
*/
private static final int SECURITY_LEVEL_VALUE_MAXIMUM = 2;
/**
* The serial version UID for this serializable class.
*/
private static final long serialVersionUID = -8884596371195896085L;
// The passphrase to use to encrypt the contents of the support data archive.
@Nullable private final ASN1OctetString encryptionPassphrase;
// Indicates whether to include binary files in the support data archive.
@Nullable private final Boolean includeBinaryFiles;
// Indicates whether to include expensive data in the support data archive.
@Nullable private final Boolean includeExpensiveData;
// Indicates whether to include third-party extension source code in the
// support data archive.
@Nullable private final Boolean includeExtensionSource;
// Indicates whether to include a replication state dump in the support data
// archive.
@Nullable private final Boolean includeReplicationStateDump;
// Indicates whether to capture information sequentially rather than in
// parallel.
@Nullable private final Boolean useSequentialMode;
// The intermediate response listener that will be used for this operation.
@NotNull private final CollectSupportDataIntermediateResponseListener
intermediateResponseListener;
// The log capture window that indicates how much log content to include in
// the support data archive.
@Nullable private final CollectSupportDataLogCaptureWindow logCaptureWindow;
// The security level to use for data included in the support data archive.
@Nullable private final CollectSupportDataSecurityLevel securityLevel;
// The number of jstacks to include in the support data archive.
@Nullable private final Integer jstackCount;
// The maximum size, in bytes, of any support data archive fragment to include
// in a collect support data archive fragment intermediate response.
@Nullable private final Integer maximumFragmentSizeBytes;
// The port of a backend Directory Server instance to which the collect
// support data extended request should be forwarded.
@Nullable private final Integer proxyToServerPort;
// The report count to use for sampled metrics.
@Nullable private final Integer reportCount;
// The report interval in seconds to use for sampled metrics.
@Nullable private final Integer reportIntervalSeconds;
// The name (without any path information) the client intends to use for the
// support data archive file.
@Nullable private final String archiveFileName;
// A comment to include in the support data archive.
@Nullable private final String comment;
// The address of a backend Directory Server to which the collect support data
// extended request should be forwarded.
@Nullable private final String proxyToServerAddress;
/**
* Creates a new instance of this extended request with the provided
* information.
*
* @param properties The properties that should be used
* for the collect support data extended
* request. It must not be
* {@code null}.
* @param intermediateResponseListener The listener that will be used to
* handle any intermediate response
* messages that are received in the
* course of processing the collect
* support data extended request. It
* must not be {@code null}.
* @param controls The controls to include in the
* collect support data extended
* request. It may be {@code null} or
* empty if no controls are needed.
*/
public CollectSupportDataExtendedRequest(
@NotNull final CollectSupportDataExtendedRequestProperties properties,
@NotNull final CollectSupportDataIntermediateResponseListener
intermediateResponseListener,
@Nullable final Control... controls)
{
super(COLLECT_SUPPORT_DATA_REQUEST_OID, encodeValue(properties), controls);
Validator.ensureNotNullWithMessage(intermediateResponseListener,
"CollectSupportDataExtendedRequest.intermediateResponseListener " +
"must not be null.");
this.intermediateResponseListener = intermediateResponseListener;
archiveFileName = properties.getArchiveFileName();
encryptionPassphrase = properties.getEncryptionPassphrase();
includeBinaryFiles = properties.getIncludeBinaryFiles();
includeExpensiveData = properties.getIncludeExpensiveData();
includeExtensionSource = properties.getIncludeExtensionSource();
includeReplicationStateDump = properties.getIncludeReplicationStateDump();
useSequentialMode = properties.getUseSequentialMode();
logCaptureWindow = properties.getLogCaptureWindow();
securityLevel = properties.getSecurityLevel();
jstackCount = properties.getJStackCount();
reportCount = properties.getReportCount();
reportIntervalSeconds = properties.getReportIntervalSeconds();
maximumFragmentSizeBytes = properties.getMaximumFragmentSizeBytes();
proxyToServerPort = properties.getProxyToServerPort();
comment = properties.getComment();
proxyToServerAddress = properties.getProxyToServerAddress();
setIntermediateResponseListener(this);
}
/**
* Constructs an ASN.1 octet string suitable for use as the value of this
* collect support data extended request from the given set of properties.
*
* @param properties The properties that should be used to construct the
* extended request value. It must not be {@code null}.
*
* @return the ASN.1 octet string that was created.
*/
@NotNull()
private static ASN1OctetString encodeValue(
@NotNull final CollectSupportDataExtendedRequestProperties properties)
{
final List elements = new ArrayList<>(20);
final String archiveFileName = properties.getArchiveFileName();
if (archiveFileName != null)
{
elements.add(new ASN1OctetString(TYPE_ARCHIVE_FILE_NAME,
archiveFileName));
}
final ASN1OctetString encryptionPassphrase =
properties.getEncryptionPassphrase();
if (encryptionPassphrase != null)
{
elements.add(encryptionPassphrase);
}
final Boolean includeExpensiveData = properties.getIncludeExpensiveData();
if (includeExpensiveData != null)
{
elements.add(new ASN1Boolean(TYPE_INCLUDE_EXPENSIVE_DATA,
includeExpensiveData));
}
final Boolean includeReplicationStateDump =
properties.getIncludeReplicationStateDump();
if (includeReplicationStateDump != null)
{
elements.add(new ASN1Boolean(TYPE_INCLUDE_REPLICATION_STATE_DUMP,
includeReplicationStateDump));
}
final Boolean includeBinaryFiles = properties.getIncludeBinaryFiles();
if (includeBinaryFiles != null)
{
elements.add(new ASN1Boolean(TYPE_INCLUDE_BINARY_FILES,
includeBinaryFiles));
}
final Boolean includeExtensionSource =
properties.getIncludeExtensionSource();
if (includeExtensionSource != null)
{
elements.add(new ASN1Boolean(TYPE_INCLUDE_EXTENSION_SOURCE,
includeExtensionSource));
}
final Boolean useSequentialMode = properties.getUseSequentialMode();
if (useSequentialMode != null)
{
elements.add(new ASN1Boolean(TYPE_USE_SEQUENTIAL_MODE,
useSequentialMode));
}
final CollectSupportDataSecurityLevel securityLevel =
properties.getSecurityLevel();
if (securityLevel != null)
{
final int securityLevelIntValue;
switch (securityLevel)
{
case NONE:
securityLevelIntValue = SECURITY_LEVEL_VALUE_NONE;
break;
case OBSCURE_SECRETS:
securityLevelIntValue = SECURITY_LEVEL_VALUE_OBSCURE_SECRETS;
break;
case MAXIMUM:
securityLevelIntValue = SECURITY_LEVEL_VALUE_MAXIMUM;
break;
default:
throw new LDAPRuntimeException(new LDAPException(
ResultCode.LOCAL_ERROR,
ERR_CSD_REQUEST_UNSUPPORTED_SECURITY_LEVEL.get(
securityLevel.getName())));
}
elements.add(new ASN1Enumerated(TYPE_SECURITY_LEVEL,
securityLevelIntValue));
}
final Integer jstackCount = properties.getJStackCount();
if (jstackCount != null)
{
elements.add(new ASN1Integer(TYPE_JSTACK_COUNT, jstackCount));
}
final Integer reportCount = properties.getReportCount();
if (reportCount != null)
{
elements.add(new ASN1Integer(TYPE_REPORT_COUNT, reportCount));
}
final Integer reportIntervalSeconds =
properties.getReportIntervalSeconds();
if (reportIntervalSeconds != null)
{
elements.add(new ASN1Integer(TYPE_REPORT_INTERVAL_SECONDS,
reportIntervalSeconds));
}
final CollectSupportDataLogCaptureWindow logCaptureWindow =
properties.getLogCaptureWindow();
if (logCaptureWindow != null)
{
elements.add(new ASN1Element(TYPE_LOG_CAPTURE_WINDOW,
logCaptureWindow.encode().encode()));
}
final String comment = properties.getComment();
if (comment != null)
{
elements.add(new ASN1OctetString(TYPE_COMMENT, comment));
}
final String proxyToServerAddress = properties.getProxyToServerAddress();
if (proxyToServerAddress != null)
{
elements.add(new ASN1Sequence(TYPE_PROXY_TO_SERVER,
new ASN1OctetString(proxyToServerAddress),
new ASN1Integer(properties.getProxyToServerPort())));
}
final Integer maximumFragmentSizeBytes =
properties.getMaximumFragmentSizeBytes();
if (maximumFragmentSizeBytes != null)
{
elements.add(new ASN1Integer(TYPE_MAXIMUM_FRAGMENT_SIZE_BYTES,
maximumFragmentSizeBytes));
}
return new ASN1OctetString(new ASN1Sequence(elements).encode());
}
/**
* Creates a new collect support data extended request that is decoded from
* the provided generic extended request.
*
* @param request The generic extended request to be
* decoded as a collect support data
* extended request. It must not be
* {@code null}.
* @param intermediateResponseListener The listener that will be used to
* handle any intermediate response
* messages that are received in the
* course of processing the collect
* support data extended request. It
* must not be {@code null}.
*
* @throws LDAPException If the provided extended request cannot be decoded
* as a valid collect support data extended request.
*/
public CollectSupportDataExtendedRequest(
@NotNull final ExtendedRequest request,
@NotNull final CollectSupportDataIntermediateResponseListener
intermediateResponseListener)
throws LDAPException
{
super(request);
Validator.ensureNotNullWithMessage(intermediateResponseListener,
"CollectSupportDataExtendedRequest.intermediateResponseListener " +
"must not be null.");
this.intermediateResponseListener = intermediateResponseListener;
final ASN1OctetString value = request.getValue();
if (value == null)
{
throw new LDAPException(ResultCode.DECODING_ERROR,
ERR_CSD_REQUEST_DECODE_NO_VALUE.get());
}
try
{
ASN1OctetString encPassphrase = null;
Boolean includeExpensive = null;
Boolean includeReplication = null;
Boolean includeBinary = null;
Boolean includeSource = null;
Boolean sequentialMode = null;
CollectSupportDataSecurityLevel secLevel = null;
Integer jCount = null;
Integer rCount = null;
Integer rInterval = null;
CollectSupportDataLogCaptureWindow lcw = null;
String archiveName = null;
String commentStr = null;
String proxyToAddress = null;
Integer proxyToPort = null;
Integer maxFragmentSize = null;
final ASN1Sequence valueSequence =
ASN1Sequence.decodeAsSequence(value.getValue());
final ASN1Element[] elements = valueSequence.elements();
for (final ASN1Element e : elements)
{
switch (e.getType())
{
case TYPE_ARCHIVE_FILE_NAME:
archiveName = ASN1OctetString.decodeAsOctetString(e).stringValue();
break;
case TYPE_ENCRYPTION_PASSPHRASE:
encPassphrase = ASN1OctetString.decodeAsOctetString(e);
break;
case TYPE_INCLUDE_EXPENSIVE_DATA:
includeExpensive = ASN1Boolean.decodeAsBoolean(e).booleanValue();
break;
case TYPE_INCLUDE_REPLICATION_STATE_DUMP:
includeReplication = ASN1Boolean.decodeAsBoolean(e).booleanValue();
break;
case TYPE_INCLUDE_BINARY_FILES:
includeBinary = ASN1Boolean.decodeAsBoolean(e).booleanValue();
break;
case TYPE_INCLUDE_EXTENSION_SOURCE:
includeSource = ASN1Boolean.decodeAsBoolean(e).booleanValue();
break;
case TYPE_USE_SEQUENTIAL_MODE:
sequentialMode = ASN1Boolean.decodeAsBoolean(e).booleanValue();
break;
case TYPE_SECURITY_LEVEL:
final int secLevelIntValue =
ASN1Enumerated.decodeAsEnumerated(e).intValue();
switch (secLevelIntValue)
{
case SECURITY_LEVEL_VALUE_NONE:
secLevel = CollectSupportDataSecurityLevel.NONE;
break;
case SECURITY_LEVEL_VALUE_OBSCURE_SECRETS:
secLevel = CollectSupportDataSecurityLevel.OBSCURE_SECRETS;
break;
case SECURITY_LEVEL_VALUE_MAXIMUM:
secLevel = CollectSupportDataSecurityLevel.MAXIMUM;
break;
default:
throw new LDAPException(ResultCode.DECODING_ERROR,
ERR_CSD_REQUEST_DECODE_UNSUPPORTED_SECURITY_LEVEL.get(
secLevelIntValue));
}
break;
case TYPE_JSTACK_COUNT:
jCount = ASN1Integer.decodeAsInteger(e).intValue();
break;
case TYPE_REPORT_COUNT:
rCount = ASN1Integer.decodeAsInteger(e).intValue();
break;
case TYPE_REPORT_INTERVAL_SECONDS:
rInterval = ASN1Integer.decodeAsInteger(e).intValue();
break;
case TYPE_LOG_CAPTURE_WINDOW:
final ASN1Element lcwElement = ASN1Element.decode(e.getValue());
try
{
lcw = CollectSupportDataLogCaptureWindow.decode(lcwElement);
}
catch (final Exception ex)
{
Debug.debugException(ex);
throw new LDAPException(ResultCode.DECODING_ERROR,
ERR_CSD_REQUEST_DECODE_LCW_FAILED.get(
StaticUtils.getExceptionMessage(ex)),
ex);
}
break;
case TYPE_COMMENT:
commentStr = ASN1OctetString.decodeAsOctetString(e).stringValue();
break;
case TYPE_PROXY_TO_SERVER:
final ASN1Element[] proxyToElements =
ASN1Sequence.decodeAsSequence(e).elements();
proxyToAddress = ASN1OctetString.decodeAsOctetString(
proxyToElements[0]).stringValue();
proxyToPort = ASN1Integer.decodeAsInteger(
proxyToElements[1]).intValue();
break;
case TYPE_MAXIMUM_FRAGMENT_SIZE_BYTES:
maxFragmentSize = ASN1Integer.decodeAsInteger(e).intValue();
break;
}
}
archiveFileName = archiveName;
encryptionPassphrase = encPassphrase;
includeExpensiveData = includeExpensive;
includeReplicationStateDump = includeReplication;
includeBinaryFiles = includeBinary;
includeExtensionSource = includeSource;
useSequentialMode = sequentialMode;
securityLevel = secLevel;
jstackCount = jCount;
reportCount = rCount;
reportIntervalSeconds = rInterval;
logCaptureWindow = lcw;
comment = commentStr;
proxyToServerAddress = proxyToAddress;
proxyToServerPort = proxyToPort;
maximumFragmentSizeBytes = maxFragmentSize;
}
catch (final LDAPException e)
{
Debug.debugException(e);
throw e;
}
catch (final Exception e)
{
Debug.debugException(e);
throw new LDAPException(ResultCode.DECODING_ERROR,
ERR_CSD_REQUEST_DECODE_ERROR.get(
StaticUtils.getExceptionMessage(e)),
e);
}
}
/**
* Retrieves the listener that will be notified when any output, archive
* fragment, or other types of intermediate response messages are received
* in response to this extended request.
*
* @return The listener that will be notified when any output, archive
* fragment, or other types of intermediate response messages are
* in response to this extended request.
*/
@NotNull()
public CollectSupportDataIntermediateResponseListener
getCollectSupportDataIntermediateResponseListener()
{
return intermediateResponseListener;
}
/**
* Retrieves the name (without any path information) that the client intends
* to use for the support data archive file.
*
* @return The name (without any path information) that the client intends to
* use for the support data archive file, or {@code null} if the
* server should generate an archive file name.
*/
@Nullable()
public String getArchiveFileName()
{
return archiveFileName;
}
/**
* Retrieves the passphrase that should be used to encrypt the contents of the
* support data archive.
*
* @return The passphrase that should be used to encrypt the contents of the
* support data archive, or {@code null} if the archive should not
* be encrypted.
*/
@Nullable()
public ASN1OctetString getEncryptionPassphrase()
{
return encryptionPassphrase;
}
/**
* Retrieves the value of a flag that indicates whether the support data
* archive may include data that is potentially expensive to collect and
* could affect the performance or responsiveness of the server.
*
* @return The value of a flag that indicates whether the support data
* archive may include data that is potentially expensive to collect,
* or {@code null} if the property should not be specified when the
* task is created (in which case the server will use a default
* behavior of excluding expensive data).
*/
@Nullable()
public Boolean getIncludeExpensiveData()
{
return includeExpensiveData;
}
/**
* Retrieves the value of a flag that indicates whether the support data
* archive may include a replication state dump, which may be several
* megabytes in size.
*
* @return The value of a flag that indicates whether the support data
* archive may include a replication state dump, or {@code null} if
* the property should not be specified when the task is created (in
* which case the server will use a default behavior of excluding the
* state dump).
*/
@Nullable()
public Boolean getIncludeReplicationStateDump()
{
return includeReplicationStateDump;
}
/**
* Retrieves the value of a flag that indicates whether the support data
* archive may include binary files.
*
* @return The value of a flag that indicates whether the support data
* archive may include binary files, or {@code null} if the property
* should not be specified when the task is created (in which case
* the server will use a default behavior of excluding binary files).
*/
@Nullable()
public Boolean getIncludeBinaryFiles()
{
return includeBinaryFiles;
}
/**
* Retrieves the value of a flag that indicates whether the support data
* archive should include source code (if available) for any third-party
* extensions installed in the server.
*
* @return The value of a flag that indicates whether the support data
* archive should include source code (if available) for any
* third-party extensions installed in the server, or {@code null} if
* the property should not be specified when the task is created (in
* which case the server will use a default behavior of excluding
* extension source code).
*/
@Nullable()
public Boolean getIncludeExtensionSource()
{
return includeExtensionSource;
}
/**
* Retrieves the value of a flag that indicates whether the server should
* collect items for the support data archive in sequential mode rather than
* in parallel. Collecting data in sequential mode may reduce the amount of
* memory consumed during the collection process, but it will take longer to
* complete.
*
* @return The value of a flag that indicates whether the server should
* collect items for the support data archive in sequential mode
* rather than in parallel, or {@code null} if the property should
* not be specified when the task is created (in which case the
* server will default to capturing data in parallel).
*/
@Nullable()
public Boolean getUseSequentialMode()
{
return useSequentialMode;
}
/**
* Retrieves the security level that should be used to indicate which data
* should be obscured, redacted, or omitted from the support data archive.
*
* @return The security level that should be used when creating the support
* data archive, or {@code null} if the property should not be
* specified when the task is created (in which case the server will
* use a default security level).
*/
@Nullable()
public CollectSupportDataSecurityLevel getSecurityLevel()
{
return securityLevel;
}
/**
* Retrieves the number of times that the jstack utility should be invoked to
* obtain stack traces from all threads in the server.
*
* @return The number of times that the jstack utility should be invoked to
* obtain stack traces from all threads in the server, or
* {@code null} if the property should not be specified when the task
* is created (in which case the server will use a default count).
*/
@Nullable()
public Integer getJStackCount()
{
return jstackCount;
}
/**
* Retrieves the number of intervals that should be captured from tools that
* use interval-based sampling (e.g., vmstat, iostat, mpstat, etc.).
*
* @return The number of intervals that should be captured from tools that
* use interval-based sampling, or {@code null} if the property
* should not be specified when the task is created (in which case
* the server will use a default report count).
*/
@Nullable()
public Integer getReportCount()
{
return reportCount;
}
/**
* Retrieves the interval duration in seconds that should be used for tools
* that use interval-based sampling (e.g., vmstat, iostat, mpstat, etc.).
*
* @return The interval duration in seconds that should be used for tools
* that use interval-based sampling, or {@code null} if the property
* should not be specified when the task is created (in which case
* the server will use a default report interval).
*/
@Nullable()
public Integer getReportIntervalSeconds()
{
return reportIntervalSeconds;
}
/**
* Retrieves the log capture window object that indicates how much log content
* should be included in the support data archive.
*
* @return The log capture window object that indicates how much log content
* should be included in the support data archive, or {@code null}
* if this should not be specified in the request and the server
* should choose an appropriate amount of log content.
*/
@Nullable()
public CollectSupportDataLogCaptureWindow getLogCaptureWindow()
{
return logCaptureWindow;
}
/**
* Retrieves an additional comment that should be included in the support data
* archive.
*
* @return An additional comment that should be included in the support data
* archive, or {@code null} if no comment should be included.
*/
@Nullable()
public String getComment()
{
return comment;
}
/**
* Retrieves the address of the backend Directory Server to which the collect
* support data extended request should be forwarded.
*
* @return The address of the backend Directory Server to which the collect
* support data extended request should be forwarded, or {@code null}
* if the request should be processed directly by the server that
* receives it.
*/
@Nullable()
public String getProxyToServerAddress()
{
return proxyToServerAddress;
}
/**
* Retrieves the port of the backend Directory Server to which the collect
* support data extended request should be forwarded.
*
* @return The port of the backend Directory Server to which the collect
* support data extended request should be forwarded, or {@code null}
* if the request should be processed directly by the server that
* receives it.
*/
@Nullable()
public Integer getProxyToServerPort()
{
return proxyToServerPort;
}
/**
* Retrieves the maximum size, in bytes, that may be used for a support data
* archive fragment returned in any single
* {@link CollectSupportDataArchiveFragmentIntermediateResponse} message.
*
* @return The maximum size, in bytes, that may be used for a support data
* archive fragment in any single archive fragment intermediate
* response message, or {@code null} if the server should use a
* default maximum fragment size.
*/
@Nullable()
public Integer getMaximumFragmentSizeBytes()
{
return maximumFragmentSizeBytes;
}
/**
* {@inheritDoc}
*/
@Override()
@NotNull()
public CollectSupportDataExtendedResult process(
@NotNull final LDAPConnection connection, final int depth)
throws LDAPException
{
final ExtendedResult extendedResponse = super.process(connection, depth);
return new CollectSupportDataExtendedResult(extendedResponse);
}
/**
* {@inheritDoc}.
*/
@Override()
@NotNull()
public CollectSupportDataExtendedRequest duplicate()
{
return duplicate(getControls());
}
/**
* {@inheritDoc}.
*/
@Override()
@NotNull()
public CollectSupportDataExtendedRequest duplicate(
@Nullable final Control[] controls)
{
final CollectSupportDataExtendedRequest r =
new CollectSupportDataExtendedRequest(
new CollectSupportDataExtendedRequestProperties(this),
intermediateResponseListener, controls);
r.setResponseTimeoutMillis(getResponseTimeoutMillis(null));
r.setReferralDepth(getReferralDepth());
r.setReferralConnector(getReferralConnectorInternal());
return r;
}
/**
* {@inheritDoc}
*/
@Override()
@NotNull()
public String getExtendedRequestName()
{
return INFO_COLLECT_SUPPORT_DATA_REQUEST_NAME.get();
}
/**
* {@inheritDoc}
*/
@Override()
public void intermediateResponseReturned(
@NotNull final IntermediateResponse intermediateResponse)
{
final String oid = intermediateResponse.getOID();
if (oid == null)
{
intermediateResponseListener.handleOtherIntermediateResponse(
intermediateResponse);
return;
}
switch (oid)
{
case CollectSupportDataOutputIntermediateResponse.
COLLECT_SUPPORT_DATA_OUTPUT_INTERMEDIATE_RESPONSE_OID:
final CollectSupportDataOutputIntermediateResponse
outputIntermediateResponse;
try
{
outputIntermediateResponse =
new CollectSupportDataOutputIntermediateResponse(
intermediateResponse);
}
catch (final Exception e)
{
Debug.debugException(e);
intermediateResponseListener.handleOtherIntermediateResponse(
intermediateResponse);
return;
}
intermediateResponseListener.handleOutputIntermediateResponse(
outputIntermediateResponse);
break;
case CollectSupportDataArchiveFragmentIntermediateResponse.
COLLECT_SUPPORT_DATA_ARCHIVE_FRAGMENT_INTERMEDIATE_RESPONSE_OID:
final CollectSupportDataArchiveFragmentIntermediateResponse
fragmentIntermediateResponse;
try
{
fragmentIntermediateResponse =
new CollectSupportDataArchiveFragmentIntermediateResponse(
intermediateResponse);
}
catch (final Exception e)
{
Debug.debugException(e);
intermediateResponseListener.handleOtherIntermediateResponse(
intermediateResponse);
return;
}
intermediateResponseListener.handleArchiveFragmentIntermediateResponse(
fragmentIntermediateResponse);
break;
default:
intermediateResponseListener.handleOtherIntermediateResponse(
intermediateResponse);
}
}
/**
* {@inheritDoc}
*/
@Override()
public void toString(@NotNull final StringBuilder buffer)
{
buffer.append("CollectSupportDataExtendedRequest(oid='");
buffer.append(getOID());
buffer.append('\'');
if (archiveFileName != null)
{
buffer.append(", archiveFileName='");
buffer.append(archiveFileName);
buffer.append('\'');
}
if (encryptionPassphrase != null)
{
buffer.append(", encryptionPassphrase='*****REDACTED*****'");
}
if (includeExpensiveData != null)
{
buffer.append(", includeExpensiveData=");
buffer.append(includeExpensiveData);
}
if (includeReplicationStateDump != null)
{
buffer.append(", includeReplicationStateDump=");
buffer.append(includeReplicationStateDump);
}
if (includeBinaryFiles != null)
{
buffer.append(", includeBinaryFiles=");
buffer.append(includeBinaryFiles);
}
if (includeExtensionSource != null)
{
buffer.append(", includeExtensionSource=");
buffer.append(includeExtensionSource);
}
if (useSequentialMode != null)
{
buffer.append(", useSequentialMode=");
buffer.append(useSequentialMode);
}
if (securityLevel != null)
{
buffer.append(", securityLevel='");
buffer.append(securityLevel.getName());
buffer.append('\'');
}
if (jstackCount != null)
{
buffer.append(", jstackCount=");
buffer.append(jstackCount);
}
if (reportCount != null)
{
buffer.append(", reportCount=");
buffer.append(reportCount);
}
if (reportIntervalSeconds != null)
{
buffer.append(", reportIntervalSeconds=");
buffer.append(reportIntervalSeconds);
}
if (logCaptureWindow != null)
{
buffer.append(", logCaptureWindow=");
logCaptureWindow.toString(buffer);
}
if (comment != null)
{
buffer.append(", comment='");
buffer.append(comment);
buffer.append('\'');
}
if (proxyToServerAddress != null)
{
buffer.append(", proxyToServerAddress='");
buffer.append(proxyToServerAddress);
buffer.append('\'');
}
if (proxyToServerPort != null)
{
buffer.append(", proxyToServerPort=");
buffer.append(proxyToServerPort);
}
if (maximumFragmentSizeBytes != null)
{
buffer.append(", maximumFragmentSizeBytes=");
buffer.append(maximumFragmentSizeBytes);
}
final Control[] controls = getControls();
if (controls.length > 0)
{
buffer.append(", controls={");
for (int i=0; i < controls.length; i++)
{
if (i > 0)
{
buffer.append(", ");
}
buffer.append(controls[i]);
}
buffer.append('}');
}
buffer.append(')');
}
}