/// <summary>
/// Configures the import session at the beginning of an import
/// </summary>
/// <param name="configParameters">The configuration parameters supplied to this management agent</param>
/// <param name="types">The schema types that apply to this import run</param>
/// <param name="importRunStep">The definition of the current run step</param>
/// <returns>Results of the import setup</returns>
OpenImportConnectionResults IMAExtensible2CallImport.OpenImportConnection(KeyedCollection <string, ConfigParameter> configParameters, Schema types, OpenImportConnectionRunStep importRunStep)
{
try
{
ManagementAgent.MAParameters = new MAParameters(configParameters);
Logger.LogPath = ManagementAgent.MAParameters.LogPath;
Logger.WriteSeparatorLine('*');
Logger.WriteLine("Starting Import");
MAConfig.Load(ManagementAgent.MAParameters.MAConfigurationFilePath);
SshConnection.OpenSshConnection(ManagementAgent.MAParameters);
OperationBase operation;
this.ImportType = importRunStep.ImportType;
this.schemaTypes = types.Types;
this.importPageSize = importRunStep.PageSize;
if (importRunStep.ImportType == OperationType.Delta)
{
operation = MAConfig.GlobalOperations.FirstOrDefault(t => t is ImportDeltaStartOperation);
}
else
{
operation = MAConfig.GlobalOperations.FirstOrDefault(t => t is ImportFullStartOperation);
}
if (operation != null)
{
try
{
SshConnection.ExecuteOperation(operation);
}
catch (Exception ex)
{
Logger.WriteLine("Could not perform import start operation");
Logger.WriteException(ex);
throw new ExtensibleExtensionException("Import start operation failed", ex);
}
}
this.importEnumerator = CSEntryImport.GetObjects(this.schemaTypes, importRunStep.ImportType).GetEnumerator();
}
catch (ExtensibleExtensionException)
{
throw;
}
catch (Exception ex)
{
Logger.WriteLine("A exception occured during the open import connection operartion");
Logger.WriteException(ex);
throw new ExtensibleExtensionException("An exception occured during the open import connection operation", ex);
}
OpenImportConnectionResults results = new OpenImportConnectionResults();
return(new OpenImportConnectionResults());
}
/// <summary>
/// Validates the configuration file parameters, and ensures the configuration file is valid and can be opened
/// </summary>
/// <param name="configParameters">The configuration parameters from the user interface</param>
/// <param name="page">The configuration page</param>
/// <returns>A ParameterValidationResult containing the validation status</returns>
public static ParameterValidationResult ValidateConfigFile(KeyedCollection <string, ConfigParameter> configParameters, ConfigParameterPage page)
{
ParameterValidationResult myResults = new ParameterValidationResult();
string path = string.Empty;
if (!configParameters.Contains(MAParameterNames.MAConfigurationFile))
{
myResults.Code = ParameterValidationResultCode.Failure;
myResults.ErrorMessage = "A configuration file must be specified";
myResults.ErrorParameter = MAParameterNames.MAConfigurationFile;
return(myResults);
}
else
{
path = configParameters[MAParameterNames.MAConfigurationFile].Value;
if (!System.IO.Path.IsPathRooted(path))
{
path = System.IO.Path.Combine(Utils.ExtensionsDirectory, path);
}
}
if (!System.IO.File.Exists(path))
{
myResults.Code = ParameterValidationResultCode.Failure;
myResults.ErrorMessage = "The configuration file does not exist";
myResults.ErrorParameter = MAParameterNames.MAConfigurationFile;
return(myResults);
}
else
{
try
{
MAConfig.Load(path);
}
catch (Exception ex)
{
myResults.Code = ParameterValidationResultCode.Failure;
myResults.ErrorMessage = string.Format("The configuration file could not be loaded\n{0}\n{1}", ex.Message, ex.InnerException == null ? string.Empty : ex.InnerException.Message);
myResults.ErrorParameter = MAParameterNames.MAConfigurationFile;
return(myResults);
}
}
myResults.Code = ParameterValidationResultCode.Success;
return(myResults);
}
/// <summary>
/// Gets the schema that applies to the objects in this management agent
/// </summary>
/// <param name="configParameters">The configuration parameters supplied to this management agent</param>
/// <returns>The Schema defining objects and attributes applicable to this management agent</returns>
Schema IMAExtensible2GetSchema.GetSchema(KeyedCollection <string, ConfigParameter> configParameters)
{
try
{
ManagementAgent.MAParameters = new MAParameters(configParameters);
Logger.LogPath = ManagementAgent.MAParameters.LogPath;
Logger.WriteSeparatorLine('*');
Logger.WriteLine("Loading Schema");
MAConfig.Load(ManagementAgent.MAParameters.MAConfigurationFilePath);
Schema schema = Schema.Create();
foreach (MASchemaObject schemaObject in MASchema.Objects)
{
SchemaType schemaType = SchemaType.Create(schemaObject.ObjectClass, true);
schemaType.Attributes.Add(SchemaAttribute.CreateAnchorAttribute("entry-dn", AttributeType.String, AttributeOperation.ImportOnly));
foreach (MASchemaAttribute attribute in schemaObject.Attributes)
{
if (attribute.IsMultiValued)
{
schemaType.Attributes.Add(SchemaAttribute.CreateMultiValuedAttribute(attribute.Name, attribute.Type, attribute.Operation));
}
else
{
schemaType.Attributes.Add(SchemaAttribute.CreateSingleValuedAttribute(attribute.Name, attribute.Type, attribute.Operation));
}
}
schema.Types.Add(schemaType);
}
Logger.WriteLine("Schema loaded successfully");
return(schema);
}
catch (Exception ex)
{
Logger.WriteException(ex);
throw new ExtensibleExtensionException("The schema could not be loaded: " + ex.Message, ex);
}
}
/// <summary>
/// Gets the capabilities of this management agent
/// </summary>
/// <param name="configParameters">The current configuration parameters for this MA</param>
/// <returns>The capabilities of this management agent</returns>
MACapabilities IMAExtensible2GetCapabilitiesEx.GetCapabilitiesEx(KeyedCollection <string, ConfigParameter> configParameters)
{
ManagementAgent.MAParameters = new MAParameters(configParameters);
MAConfig.Load(ManagementAgent.MAParameters.MAConfigurationFilePath);
MACapabilities capabilities = new MACapabilities
{
ConcurrentOperation = true,
ObjectRename = MAConfig.Capabilities.ObjectRenameAllowed,
DeleteAddAsReplace = MAConfig.Capabilities.DeleteAddAsReplace,
ExportType = MAConfig.Capabilities.ObjectUpdateMode,
DeltaImport = MAConfig.Capabilities.DeltaImport,
DistinguishedNameStyle = MADistinguishedNameStyle.Generic,
NoReferenceValuesInFirstExport = false,
Normalizations = MANormalizations.None,
IsDNAsAnchor = false
};
return(capabilities);
}
/// <summary>
/// Begins a password connection to the server
/// </summary>
/// <param name="configParameters">The collection of configuration parameters</param>
/// <param name="partition">The partition details on which the password operation should occur</param>
void IMAExtensible2Password.OpenPasswordConnection(KeyedCollection <string, ConfigParameter> configParameters, Partition partition)
{
try
{
ManagementAgent.MAParameters = new MAParameters(configParameters);
Logger.LogPath = ManagementAgent.MAParameters.LogPath;
Logger.WriteSeparatorLine('*');
Logger.WriteLine("Starting password operation");
MAConfig.Load(ManagementAgent.MAParameters.MAConfigurationFilePath);
SshConnection.OpenSshConnection(ManagementAgent.MAParameters);
OperationBase operation = MAConfig.GlobalOperations.FirstOrDefault(t => t is PasswordStartOperation);
if (operation != null)
{
try
{
SshConnection.ExecuteOperation(operation);
}
catch (Exception ex)
{
Logger.WriteLine("Could not perform password start operation");
Logger.WriteException(ex);
throw new ExtensibleExtensionException("Password start operation failed", ex);
}
}
}
catch (ExtensibleExtensionException)
{
throw;
}
catch (Exception ex)
{
Logger.WriteLine("A exception occured during the open password connection operartion");
Logger.WriteException(ex);
throw new ExtensibleExtensionException("An exception occured during the open password connection operation", ex);
}
}
/// <summary>
/// Begins an export session
/// </summary>
/// <param name="configParameters">The configuration parameters supplied to this management agent</param>
/// <param name="types">The schema types that apply to this export run</param>
/// <param name="exportRunStep">The definition of the current run step</param>
void IMAExtensible2CallExport.OpenExportConnection(KeyedCollection <string, ConfigParameter> configParameters, Schema types, OpenExportConnectionRunStep exportRunStep)
{
try
{
ManagementAgent.MAParameters = new MAParameters(configParameters);
Logger.LogPath = ManagementAgent.MAParameters.LogPath;
Logger.WriteSeparatorLine('*');
Logger.WriteLine("Starting Export");
MAConfig.Load(ManagementAgent.MAParameters.MAConfigurationFilePath);
SshConnection.OpenSshConnection(ManagementAgent.MAParameters);
OperationBase operation = MAConfig.GlobalOperations.FirstOrDefault(t => t is ExportStartOperation);
if (operation != null)
{
try
{
SshConnection.ExecuteOperation(operation);
}
catch (Exception ex)
{
Logger.WriteLine("Could not perform export start operation");
Logger.WriteException(ex);
throw new ExtensibleExtensionException("Export start operation failed", ex);
}
}
}
catch (ExtensibleExtensionException)
{
throw;
}
catch (Exception ex)
{
Logger.WriteLine("A exception occured during the open export connection operartion");
Logger.WriteException(ex);
throw new ExtensibleExtensionException("An exception occured during the open export connection operation", ex);
}
}