void RevertImpersonation()
{
if (!ShouldImpersonate())
{
return;
}
Tracer.Enter("revertimpersonation");
Tracer.Indent();
try
{
Tracer.TraceInformation("closing-impersonation-context");
m_ImpersonationContext.Undo();
Tracer.TraceInformation("closing-impersonation-tokenhandle {0}", impersonationToken);
NativeMethods.CloseHandle(impersonationToken);
Tracer.TraceInformation("closing-impersonation-duplicated-tokenhandle {0}", tokenDuplicate);
NativeMethods.CloseHandle(tokenDuplicate);
}
catch (Exception ex)
{
Tracer.TraceError("revertimpersonation", ex);
throw;
}
finally
{
Tracer.Unindent();
Tracer.Exit("revertimpersonation");
}
}
public CloseImportConnectionResults CloseImportConnection(CloseImportConnectionRunStep importRunStep)
{
Tracer.Enter("closeimportconnectionresults");
Tracer.Indent();
try
{
CloseRunspace();
//RevertImpersonation();
CloseImportConnectionResults cicr = new CloseImportConnectionResults();
Tracer.TraceInformation("custom-data {0}", importRunStep.CustomData);
Tracer.TraceInformation("close-reason {0}", importRunStep.Reason);
if (importRunStep.Reason == CloseReason.Normal)
{
cicr.CustomData = importRunStep.CustomData;
}
Dispose();
return(cicr);
}
catch (Exception ex)
{
Tracer.TraceError("closeimportconnection", ex);
throw;
}
finally
{
Tracer.Unindent();
Tracer.Exit("closeimportconnectionresults");
}
}
void IMAExtensible2CallExport.OpenExportConnection(System.Collections.ObjectModel.KeyedCollection <string, ConfigParameter> configParameters, Schema types, OpenExportConnectionRunStep exportRunStep)
{
Tracer.IndentLevel = 0;
Tracer.Enter("openexportconnection");
Tracer.Indent();
try
{
InitializeConfigParameters(configParameters);
OpenRunspace();
schema = types;
exportType = exportRunStep.ExportType;
Tracer.TraceInformation("export-type '{0}'", exportType);
exportBatchSize = exportRunStep.BatchSize;
Tracer.TraceInformation("export-batch-size '{0}'", exportBatchSize);
}
catch (Exception ex)
{
Tracer.TraceError("openexportconnection", ex);
throw new TerminateRunException(ex.Message);
}
finally
{
Tracer.Unindent();
Tracer.Exit("openexportconnection");
}
}
IList <ConfigParameterDefinition> IMAExtensible2GetParameters.GetConfigParameters(System.Collections.ObjectModel.KeyedCollection <string, ConfigParameter> configParameters, ConfigParameterPage page)
{
Tracer.Enter("getconfigparameters");
Tracer.Indent();
try
{
List <ConfigParameterDefinition> configParametersDefinitions = new List <ConfigParameterDefinition>();
switch (page)
{
case ConfigParameterPage.Connectivity:
configParametersDefinitions.Add(ConfigParameterDefinition.CreateLabelParameter("The Schema script is called to retrieve the object and attribute definitions. This script should be accessible to the FIM Synchronization Service service account during configuration and refreshes of the schema."));
configParametersDefinitions.Add(ConfigParameterDefinition.CreateStringParameter(Constants.Parameters.SchemaScript, ""));
configParametersDefinitions.Add(ConfigParameterDefinition.CreateDividerParameter());
configParametersDefinitions.Add(ConfigParameterDefinition.CreateLabelParameter("Authentication (optional): These credentials are passed as parameters to all scripts."));
configParametersDefinitions.Add(ConfigParameterDefinition.CreateStringParameter(Constants.Parameters.Username, ""));
configParametersDefinitions.Add(ConfigParameterDefinition.CreateEncryptedStringParameter(Constants.Parameters.Password, ""));
configParametersDefinitions.Add(ConfigParameterDefinition.CreateDividerParameter());
configParametersDefinitions.Add(ConfigParameterDefinition.CreateLabelParameter("Impersonation (optional): If username and password below are specified (domain optional), the specified user is used to run all scripts. If not specified, the scripts are run in the security context of the FIM Synchronization Service service account."));
configParametersDefinitions.Add(ConfigParameterDefinition.CreateStringParameter(Constants.Parameters.ImpersonationDomain, ""));
configParametersDefinitions.Add(ConfigParameterDefinition.CreateStringParameter(Constants.Parameters.ImpersonationUsername, ""));
configParametersDefinitions.Add(ConfigParameterDefinition.CreateEncryptedStringParameter(Constants.Parameters.ImpersonationPassword, ""));
break;
case ConfigParameterPage.Global:
configParametersDefinitions.Add(ConfigParameterDefinition.CreateLabelParameter("Scripts"));
configParametersDefinitions.Add(ConfigParameterDefinition.CreateLabelParameter("These are the PowerShell scripts that are run on the different operations. You should specify the full path of the scripts. Path cannot include spaces or similar whitespaces."));
configParametersDefinitions.Add(ConfigParameterDefinition.CreateStringParameter(Constants.Parameters.ImportScript, ""));
configParametersDefinitions.Add(ConfigParameterDefinition.CreateStringParameter(Constants.Parameters.ExportScript, ""));
configParametersDefinitions.Add(ConfigParameterDefinition.CreateCheckBoxParameter(Constants.Parameters.UsePagedImport, false));
configParametersDefinitions.Add(ConfigParameterDefinition.CreateDividerParameter());
configParametersDefinitions.Add(ConfigParameterDefinition.CreateLabelParameter("If you enable Password Management, this script is called for both password change and set (requires PCNS)."));
configParametersDefinitions.Add(ConfigParameterDefinition.CreateStringParameter(Constants.Parameters.PasswordManagementScript, ""));
configParametersDefinitions.Add(ConfigParameterDefinition.CreateDividerParameter());
configParametersDefinitions.Add(ConfigParameterDefinition.CreateLabelParameter("The objects piped to the export script will normally be of type PSCustomObject. If you uncheck this, you will get objects of more complex type CSEntryChange instead (legacy behaviour). For more information on the CSEntryChange object type, please see MSDN Library."));
configParametersDefinitions.Add(ConfigParameterDefinition.CreateCheckBoxParameter(Constants.Parameters.ExportSimpleObjects, true));
break;
case ConfigParameterPage.Partition:
break;
case ConfigParameterPage.RunStep:
break;
}
return(configParametersDefinitions);
}
catch (Exception ex)
{
Tracer.TraceError("getconfigparameters", ex);
throw;
}
finally
{
Tracer.Exit("getconfigparameters");
}
}
public PowerShellManagementAgent()
{
Tracer.IndentLevel = 0;
Tracer.Enter("initialize");
Tracer.Indent();
try
{
Tracer.TraceInformation("memory-usage {0:n} Mb", GC.GetTotalMemory(true) / 102400);
System.Reflection.Assembly assembly = System.Reflection.Assembly.GetExecutingAssembly();
FileVersionInfo fvi = FileVersionInfo.GetVersionInfo(assembly.Location);
string version = fvi.FileVersion;
Tracer.TraceInformation("psma-version {0}", version);
Tracer.TraceInformation("reading-registry-settings");
RegistryKey machineRegistry = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry64);
RegistryKey mreRootKey = machineRegistry.OpenSubKey(@"SOFTWARE\Granfeldt\FIM\ManagementAgents\PowerShell", false);
if (mreRootKey != null)
{
Tracer.TraceInformation("adding-eventlog-listener-for name: {0}, source: {1}", EventLogName, EventLogSource);
EventLog evl = new EventLog(EventLogName);
evl.Log = EventLogName;
evl.Source = EventLogSource;
EventLogTraceListener eventLog = new EventLogTraceListener(EventLogSource);
eventLog.EventLog = evl;
EventTypeFilter filter = new EventTypeFilter(SourceLevels.Warning | SourceLevels.Error | SourceLevels.Critical);
eventLog.TraceOutputOptions = TraceOptions.Callstack;
eventLog.Filter = filter;
Tracer.Trace.Listeners.Add(eventLog);
if (!EventLog.SourceExists(EventLogSource))
{
Tracer.TraceInformation("creating-eventlog-source '{0}'", EventLogSource);
EventLog.CreateEventSource(EventLogSource, EventLogName);
}
string logFileValue = mreRootKey.GetValue("DebugLogFileName", null) as string;
if (logFileValue != null)
{
Tracer.TraceWarning("Logging to file is no longer supported. Please remove registrykey DebugLogFileName and use DebugView or similar instead to catch traces from this Management Agent");
}
}
}
catch (Exception ex)
{
Tracer.TraceError("could-not-initialize", ex);
throw;
}
finally
{
Tracer.Unindent();
Tracer.Exit("initialize");
}
}
void CallPasswordScript(PasswordOperation Action, CSEntry csentry, SecureString oldPassword, SecureString newPassword, PasswordOptions options)
{
Tracer.Enter("callpasswordscript");
Tracer.Indent();
PSDataCollection <PSObject> passwordPipeline = new PSDataCollection <PSObject>();
try
{
Command cmd = new Command(Path.GetFullPath(PasswordManagementScript));
cmd.Parameters.Add(new CommandParameter("User", Username));
cmd.Parameters.Add(new CommandParameter("Password", Password));
cmd.Parameters.Add(new CommandParameter("Credentials", GetSecureCredentials()));
cmd.Parameters.Add(new CommandParameter("Action", Action.ToString()));
if (options.HasFlag(PasswordOptions.UnlockAccount))
{
cmd.Parameters.Add(new CommandParameter("UnlockAccount"));
}
if (options.HasFlag(PasswordOptions.ForceChangeAtLogOn))
{
cmd.Parameters.Add(new CommandParameter("ForceChangeAtLogOn"));
}
if (options.HasFlag(PasswordOptions.ValidatePassword))
{
cmd.Parameters.Add(new CommandParameter("ValidatePassword"));
}
cmd.Parameters.Add(new CommandParameter("NewPassword", newPassword.ConvertToUnsecureString()));
if (Action == PasswordOperation.Change)
{
cmd.Parameters.Add(new CommandParameter("OldPassword", oldPassword.ConvertToUnsecureString()));
}
passwordPipeline.Add(new PSObject(csentry));
passwordResults = InvokePowerShellScript(cmd, passwordPipeline);
}
catch (Exception ex)
{
Tracer.TraceError("callpasswordscript", ex);
throw;
}
finally
{
passwordPipeline = null;
Tracer.Unindent();
Tracer.TraceInformation("callpasswordscript");
}
}
ParameterValidationResult IMAExtensible2GetParameters.ValidateConfigParameters(System.Collections.ObjectModel.KeyedCollection <string, ConfigParameter> configParameters, ConfigParameterPage page)
{
try
{
Tracer.Enter("validateconfigparameters");
Tracer.Indent();
if (page == ConfigParameterPage.Connectivity)
{
string schemaScriptFilename = Path.GetFullPath(configParameters[Constants.Parameters.SchemaScript].Value);
if (!File.Exists(schemaScriptFilename))
{
return(new ParameterValidationResult(ParameterValidationResultCode.Failure, string.Format("Can not find or access Schema script '{0}'. Please make sure that the FIM Synchronization Service service account can read and access this file.", schemaScriptFilename), Constants.Parameters.SchemaScript));
}
}
if (page == ConfigParameterPage.Global)
{
string importScriptFilename = Path.GetFullPath(configParameters[Constants.Parameters.ImportScript].Value);
if (!File.Exists(importScriptFilename))
{
return(new ParameterValidationResult(ParameterValidationResultCode.Failure, string.Format("Can not find or access Import script '{0}'. Please make sure that the FIM Synchronization Service service account can read and access this file.", importScriptFilename), Constants.Parameters.ImportScript));
}
string exportScriptFilename = Path.GetFullPath(configParameters[Constants.Parameters.ExportScript].Value);
if (!File.Exists(exportScriptFilename))
{
return(new ParameterValidationResult(ParameterValidationResultCode.Failure, string.Format("Can not find or access Export script '{0}'. Please make sure that the FIM Synchronization Service service account can read and access this file.", exportScriptFilename), Constants.Parameters.ExportScript));
}
string passwordManagementScriptFilename = Path.GetFullPath(configParameters[Constants.Parameters.PasswordManagementScript].Value);
if (!File.Exists(passwordManagementScriptFilename))
{
return(new ParameterValidationResult(ParameterValidationResultCode.Failure, string.Format("Can not find or access Password Management script '{0}'. Please make sure that the FIM Synchronization Service service account can read and access this file.", passwordManagementScriptFilename), Constants.Parameters.PasswordManagementScript));
}
}
}
catch (Exception ex)
{
Tracer.TraceError("validateconfigparameters", ex);
throw;
}
finally
{
Tracer.Unindent();
Tracer.Exit("validateconfigparameters");
}
return(new ParameterValidationResult(ParameterValidationResultCode.Success, "", ""));
}
void IMAExtensible2Password.ChangePassword(CSEntry csentry, SecureString oldPassword, SecureString newPassword)
{
Tracer.Enter("changepassword");
Tracer.Indent();
try
{
CallPasswordScript(PasswordOperation.Change, csentry, oldPassword, newPassword, PasswordOptions.None);
}
catch (Exception ex)
{
Tracer.TraceError("changepassword", ex);
throw;
}
finally
{
Tracer.Unindent();
Tracer.Exit("changepassword");
}
}
void IMAExtensible2Password.SetPassword(CSEntry csentry, SecureString newPassword, PasswordOptions options)
{
Tracer.Enter("setpassword");
Tracer.Indent();
try
{
CallPasswordScript(PasswordOperation.Set, csentry, new SecureString(), newPassword, options);
}
catch (Exception ex)
{
Tracer.TraceError("setpassword", ex);
throw;
}
finally
{
Tracer.Unindent();
Tracer.Exit("setpassword");
}
}
void IMAExtensible2CallExport.CloseExportConnection(CloseExportConnectionRunStep exportRunStep)
{
Tracer.Enter("closeexportconnection");
Tracer.Indent();
try
{
CloseRunspace();
Dispose();
}
catch (Exception ex)
{
Tracer.TraceError("closeexportconnection", ex);
throw;
}
finally
{
Tracer.Unindent();
Tracer.Exit("closeexportconnection");
}
}
void IMAExtensible2Password.ClosePasswordConnection()
{
Tracer.Enter("closepasswordconnection");
Tracer.Indent();
try
{
CloseRunspace();
Dispose();
}
catch (Exception ex)
{
Tracer.TraceError("closepasswordconnection", ex);
throw;
}
finally
{
Tracer.Unindent();
Tracer.Exit("closepasswordconnection");
}
}
void CloseRunspace()
{
Tracer.Enter("closerunspace");
Tracer.Indent();
try
{
if (powershell != null)
{
Tracer.TraceInformation("disposing-powershell");
powershell.Runspace.Close();
powershell.Dispose();
Tracer.TraceInformation("disposed-powershell");
}
if (runspace != null)
{
Tracer.TraceInformation("runspace-state '{0}'", runspace.RunspaceStateInfo.State);
if (runspace.RunspaceStateInfo.State != RunspaceState.Closed)
{
Tracer.TraceInformation("removing-runspace-eventhandlers");
runspace.StateChanged -= Runspace_StateChanged;
runspace.AvailabilityChanged -= Runspace_AvailabilityChanged;
Tracer.TraceInformation("removed-runspace-eventhandlers");
Tracer.TraceInformation("dispose-runspace");
runspace.Dispose(); // dispose also closes runspace
Tracer.TraceInformation("disposed-runspace");
}
}
}
catch (Exception ex)
{
Tracer.TraceError("closerunspace", ex);
throw;
}
finally
{
Tracer.Unindent();
Tracer.Exit("closerunspace");
}
}
void IMAExtensible2Password.OpenPasswordConnection(KeyedCollection <string, ConfigParameter> configParameters, Partition partition)
{
Tracer.IndentLevel = 0;
Tracer.Enter("openpasswordconnection");
Tracer.Indent();
try
{
InitializeConfigParameters(configParameters);
OpenRunspace();
}
catch (Exception ex)
{
Tracer.TraceError("openpasswordconnection", ex);
throw;
}
finally
{
Tracer.Unindent();
Tracer.Exit("openpasswordconnection");
}
}
public void Dispose()
{
Tracer.Enter("dispose");
Tracer.Indent();
try
{
Tracer.TraceInformation("clearing-variables");
csentryqueue = null;
objectTypeAnchorAttributeNames = null;
Tracer.TraceInformation("collection-garbage");
GC.Collect(0, GCCollectionMode.Default, true);
}
catch (Exception ex)
{
Tracer.TraceError(ex.ToString());
throw;
}
finally
{
Tracer.Unindent();
Tracer.Exit("dispose");
}
}
void WhoAmI()
{
Tracer.Enter("show-identity");
Tracer.Indent();
try
{
using (WindowsIdentity currentIdentity = WindowsIdentity.GetCurrent())
{
Tracer.TraceInformation("identity-name: {0}", currentIdentity.Name);
Tracer.TraceInformation("identity-token: {0}", currentIdentity.Token);
Tracer.TraceInformation("identity-user-value: {0}", currentIdentity.User.Value);
if (currentIdentity.Actor != null)
{
Tracer.TraceInformation("identity-actor: {0}", currentIdentity.Actor.Name);
Tracer.TraceInformation("identity-actor-auth-type: {0}", currentIdentity.Actor.AuthenticationType);
}
if (currentIdentity.Groups != null)
{
foreach (IdentityReference group in currentIdentity.Groups)
{
NTAccount account = group.Translate(typeof(NTAccount)) as NTAccount;
Tracer.TraceInformation("group-membership {0}", account.Value);
}
}
}
}
catch (Exception ex)
{
Tracer.TraceError("error-showing-current-identity", ex);
throw;
}
finally
{
Tracer.Unindent();
Tracer.Exit("show-identity");
}
}
Schema IMAExtensible2GetSchema.GetSchema(KeyedCollection <string, ConfigParameter> configParameters)
{
Tracer.Enter("getschema");
Tracer.Indent();
try
{
Schema schema = Schema.Create();
InitializeConfigParameters(configParameters);
OpenRunspace();
Command cmd = new Command(Path.GetFullPath(SchemaScript));
cmd.Parameters.Add(new CommandParameter("Username", Username));
cmd.Parameters.Add(new CommandParameter("Password", Password));
cmd.Parameters.Add(new CommandParameter("Credentials", GetSecureCredentials()));
schemaResults = InvokePowerShellScript(cmd, null);
CloseRunspace();
if (schemaResults != null)
{
foreach (PSObject obj in schemaResults)
{
string objectTypeName = null;
HashSet <AttributeDefinition> attrs = new HashSet <AttributeDefinition>();
foreach (PSPropertyInfo p in obj.Properties)
{
string[] elements = p.Name.Split(new char[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
string attrName = elements[0].Trim();
string attrType = elements[1].Trim();
if (string.Equals(attrName, Constants.ControlValues.ObjectClass, StringComparison.OrdinalIgnoreCase))
{
objectTypeName = p.Value.ToString();
Tracer.TraceInformation("object-class '{0}'", objectTypeName);
}
else
{
AttributeDefinition ad = new AttributeDefinition();
ad.Name = Regex.Replace(attrName, "^Anchor-", "", RegexOptions.IgnoreCase);
ad.IsAnchor = p.Name.StartsWith("anchor-", StringComparison.OrdinalIgnoreCase);
ad.IsMultiValue = p.Name.EndsWith("[]", StringComparison.OrdinalIgnoreCase);
switch (attrType.Replace("[]", "").ToLower())
{
case "boolean":
ad.Type = AttributeType.Boolean;
break;
case "binary":
ad.Type = AttributeType.Binary;
break;
case "integer":
ad.Type = AttributeType.Integer;
break;
case "reference":
ad.Type = AttributeType.Reference;
break;
case "string":
ad.Type = AttributeType.String;
break;
default:
ad.Type = AttributeType.String;
break;
}
Tracer.TraceInformation("name '{0}', isanchor: {1}, ismultivalue: {2}, type: {3}", ad.Name, ad.IsAnchor, ad.IsMultiValue, ad.Type.ToString());
attrs.Add(ad);
}
}
if (string.IsNullOrEmpty(objectTypeName))
{
Tracer.TraceError("missing-object-class");
throw new Microsoft.MetadirectoryServices.NoSuchObjectTypeException();
}
SchemaType objectClass = SchemaType.Create(objectTypeName, true);
foreach (AttributeDefinition def in attrs)
{
if (def.IsAnchor)
{
objectClass.Attributes.Add(SchemaAttribute.CreateAnchorAttribute(def.Name, def.Type));
}
else
{
if (def.IsMultiValue)
{
objectClass.Attributes.Add(SchemaAttribute.CreateMultiValuedAttribute(def.Name, def.Type));
}
else
{
objectClass.Attributes.Add(SchemaAttribute.CreateSingleValuedAttribute(def.Name, def.Type));
}
}
}
if (objectClass.AnchorAttributes.Count == 1)
{
schema.Types.Add(objectClass);
}
else
{
Tracer.TraceError("missing-anchor-definition-on-object");
throw new Microsoft.MetadirectoryServices.AttributeNotPresentException();
}
}
}
schemaResults.Clear();
return(schema);
}
catch (Exception ex)
{
Tracer.TraceError("getschema", ex);
throw;
}
finally
{
Tracer.Unindent();
Tracer.Exit("getschema");
}
}
PutExportEntriesResults IMAExtensible2CallExport.PutExportEntries(IList <CSEntryChange> csentries)
{
Tracer.Enter("putexportentries");
Tracer.Indent();
PutExportEntriesResults exportEntries = new PutExportEntriesResults();
PSDataCollection <PSObject> exportPipeline = new PSDataCollection <PSObject>();
try
{
Command cmd = new Command(Path.GetFullPath(ExportScript));
cmd.Parameters.Add(new CommandParameter("User", Username));
cmd.Parameters.Add(new CommandParameter("Password", Password));
cmd.Parameters.Add(new CommandParameter("Credentials", GetSecureCredentials()));
cmd.Parameters.Add(new CommandParameter("ExportType", exportType));
foreach (CSEntryChange csentryChange in csentries)
{
Tracer.TraceInformation("adding-object id: {0}, dn: '{1}' [{2}]", csentryChange.Identifier, csentryChange.DN, csentryChange.ObjectModificationType);
if (ExportSimpleObjects)
{
// http://karlprosser.com/coder/2008/06/12/generating-a-propertybag-aka-pscustomobject-in-c/
// creating a PSobject without any parameters in the constructor creates a PSCustomObject
PSObject obj = new PSObject();
// PSNoteProperties are not strongly typed but do contain an explicit type.
obj.Properties.Add(new PSNoteProperty(Constants.ControlValues.Identifier, csentryChange.Identifier.ToString()));
obj.Properties.Add(new PSNoteProperty(Constants.ControlValues.Anchor, csentryChange.AnchorAttributes.Count > 0 ? csentryChange.AnchorAttributes.FirstOrDefault().Value : ""));
obj.Properties.Add(new PSAliasProperty(Constants.ControlValues.IdentifierAsGuid, csentryChange.Identifier.ToString(), typeof(Guid)));
obj.Properties.Add(new PSNoteProperty(Constants.ControlValues.ObjectModificationType, csentryChange.ObjectModificationType.ToString()));
obj.Properties.Add(new PSNoteProperty(Constants.ControlValues.ObjectType, csentryChange.ObjectType));
List <string> attrs = schema.Types[csentryChange.ObjectType].Attributes.Select(a => a.Name).ToList <string>();
obj.Properties.Add(new PSNoteProperty(Constants.ControlValues.AttributeNames, attrs));
obj.Properties.Add(new PSNoteProperty(Constants.ControlValues.ChangedAttributeNames, csentryChange.ChangedAttributeNames == null ? new List <string>() : csentryChange.ChangedAttributeNames));
obj.Properties.Add(new PSNoteProperty(Constants.ControlValues.DN, csentryChange.DN));
obj.Properties.Add(new PSNoteProperty(Constants.ControlValues.RDN, csentryChange.RDN));
foreach (AttributeChange ac in csentryChange.AttributeChanges)
{
if (!ac.IsMultiValued)
{
foreach (ValueChange vc in ac.ValueChanges)
{
obj.Properties.Add(new PSNoteProperty(string.Format("{0}", ac.Name), vc.Value));
}
}
else
{
List <object> values = new List <object>();
foreach (ValueChange vc in ac.ValueChanges)
{
values.Add(vc.Value);
}
obj.Properties.Add(new PSNoteProperty(string.Format("{0}", ac.Name), values.ToArray()));
}
}
exportPipeline.Add(obj);
}
else
{
exportPipeline.Add(new PSObject(csentryChange));
}
}
exportResults = InvokePowerShellScript(cmd, exportPipeline);
if (exportResults != null)
{
foreach (PSObject result in exportResults)
{
if (result.BaseObject.GetType() != typeof(System.Collections.Hashtable))
{
continue;
}
Hashtable hashTable = (Hashtable)result.BaseObject;
string ErrorName = "unspecified-error";
string ErrorDetail = "No details specified";
Guid identifier = new Guid();
// get anchor attribute changes
List <AttributeChange> attrchanges = new List <AttributeChange>();
foreach (string key in hashTable.Keys)
{
if (key.Equals(Constants.ControlValues.Identifier, StringComparison.OrdinalIgnoreCase))
{
try
{
identifier = new Guid(hashTable[key].ToString());
Tracer.TraceInformation("got-identifier {0}, {1}", identifier, key);
}
catch (FormatException fex)
{
Tracer.TraceError("identifier-format-error '{0}'", fex.ToString());
}
continue;
}
if (key.Equals(Constants.ControlValues.ErrorName, StringComparison.OrdinalIgnoreCase))
{
ErrorName = hashTable[key].ToString();
Tracer.TraceInformation("got-errorname {0}, {1}", ErrorName, key);
continue;
}
if (key.Equals(Constants.ControlValues.ErrorDetail, StringComparison.OrdinalIgnoreCase))
{
ErrorDetail = hashTable[key].ToString();
Tracer.TraceInformation("got-errordetail {0}, {1}", ErrorDetail, key);
continue;
}
if (!(Regex.IsMatch(key, @"^\[.+\]$", RegexOptions.IgnoreCase)))
{
Tracer.TraceInformation("got-attribute-change {0}: '{1}'", key, hashTable[key]);
attrchanges.Add(AttributeChange.CreateAttributeAdd(key, hashTable[key]));
continue;
}
}
if (string.IsNullOrEmpty(ErrorName) || ErrorName.Equals("success", StringComparison.OrdinalIgnoreCase))
{
Tracer.TraceInformation("returning-success id: {0}", identifier);
CSEntryChangeResult cschangeresult = CSEntryChangeResult.Create(identifier, attrchanges, MAExportError.Success);
exportEntries.CSEntryChangeResults.Add(cschangeresult);
}
else
{
Tracer.TraceInformation("returning-error id: {0}, name: {1}, details: {2}", identifier, ErrorName, ErrorDetail);
CSEntryChangeResult cschangeresult = CSEntryChangeResult.Create(identifier, attrchanges, MAExportError.ExportErrorCustomContinueRun, ErrorName, ErrorDetail);
exportEntries.CSEntryChangeResults.Add(cschangeresult);
}
}
}
exportPipeline.Clear();
exportResults.Clear();
exportResults = null;
return(exportEntries);
}
catch (Exception ex)
{
Tracer.TraceError("putexportentries", ex);
throw;
}
finally
{
Tracer.Unindent();
Tracer.Exit("putexportentries");
}
}
public GetImportEntriesResults GetImportEntries(GetImportEntriesRunStep importRunStep)
{
Tracer.Enter("getimportentries");
Tracer.Indent();
try
{
#region call import script
// if results is null, then this is the first time that we're called,
// so call script and get pipeline object and custom data
Tracer.TraceInformation("more-to-import '{0}'", MoreToImport);
if (MoreToImport)
{
MoreToImport = false; // make sure we set more-to-import to false; could be overwritten further down if pagedimports is true, though
// on first call, we set customdata to value from last successful run
returnedCustomData = importRunStep.CustomData;
Command cmd = new Command(Path.GetFullPath(ImportScript));
cmd.Parameters.Add(new CommandParameter("User", Username));
cmd.Parameters.Add(new CommandParameter("Password", Password));
cmd.Parameters.Add(new CommandParameter("Credentials", GetSecureCredentials()));
cmd.Parameters.Add(new CommandParameter("OperationType", importOperationType.ToString()));
cmd.Parameters.Add(new CommandParameter("UsePagedImport", UsePagedImport));
cmd.Parameters.Add(new CommandParameter("PageSize", ImportRunStepPageSize));
Tracer.TraceInformation("setting-custom-data '{0}'", importRunStep.CustomData);
powershell.Runspace.SessionStateProxy.SetVariable("RunStepCustomData", importRunStep.CustomData);
Tracer.TraceInformation("setting-page-token '{0}'", pageToken);
powershell.Runspace.SessionStateProxy.SetVariable("PageToken", pageToken);
importResults = InvokePowerShellScript(cmd, null).ToList <PSObject>();
returnedCustomData = powershell.Runspace.SessionStateProxy.GetVariable("RunStepCustomData");
pageToken = powershell.Runspace.SessionStateProxy.GetVariable("PageToken");
Tracer.TraceInformation("page-token-returned '{0}'", pageToken == null ? "(null)" : pageToken);
Tracer.TraceInformation("custom-data returned '{0}'", returnedCustomData);
Tracer.TraceInformation("number-of-object(s)-in-pipeline {0:n0}", importResults.Count);
if (UsePagedImport)
{
Tracer.TraceError("paged-import-not-supported-currently");
object moreToImportObject = powershell.Runspace.SessionStateProxy.GetVariable("MoreToImport");
if (moreToImportObject == null)
{
Tracer.TraceError("For paged imports, the global variable 'MoreToImport' must be set to 'true' or 'false'");
}
else
{
Tracer.TraceInformation("MoreToImport-value-returned '{0}'", moreToImportObject);
if (bool.TryParse(moreToImportObject == null ? bool.FalseString : moreToImportObject.ToString(), out MoreToImport))
{
Tracer.TraceInformation("paged-import-setting-MoreToImport-to '{0}'", MoreToImport);
}
else
{
Tracer.TraceError("Value returned in MoreToImport must be a boolean with value of 'true' or 'false'");
}
}
}
else
{
MoreToImport = false;
Tracer.TraceInformation("non-paged-import-setting-MoreToImport-to '{0}'", MoreToImport);
}
}
#endregion
#region parse returned objects
if (importResults != null && importResults.Count > 0)
{
List <PSObject> importResultsBatch = importResults.Take(ImportRunStepPageSize).ToList();
if (importResults.Count > ImportRunStepPageSize)
{
importResults.RemoveRange(0, importResultsBatch.Count);
}
else
{
importResults.Clear();
}
Tracer.TraceInformation("converting-objects-to-csentrychange {0:n0}", importResultsBatch.Count);
foreach (PSObject obj in importResultsBatch)
{
HashSet <AttributeDefinition> attrs = new HashSet <AttributeDefinition>();
Tracer.TraceInformation("start-connector-space-object");
Tracer.Indent();
try
{
CSEntryChange csobject = CSEntryChange.Create();
if (obj.BaseObject.GetType() != typeof(System.Collections.Hashtable))
{
Tracer.TraceWarning("invalid-object-in-pipeline '{0}'", obj.BaseObject.GetType());
continue;
}
object AnchorValue = null;
string AnchorAttributeName = null;
string objectDN = null;
string objectClass = ""; // should be string to prevent null exceptions
string changeType = null;
string ErrorName = null;
string ErrorDetail = null;
MAImportError ImportErrorType = MAImportError.Success; // assume no error
Hashtable hashTable = (Hashtable)obj.BaseObject;
#region get control values
Tracer.TraceInformation("start-getting-control-values");
Tracer.Indent();
foreach (string key in hashTable.Keys)
{
if (key.Equals(Constants.ControlValues.ObjectClass, StringComparison.OrdinalIgnoreCase) || key.Equals(Constants.ControlValues.ObjectClassEx, StringComparison.OrdinalIgnoreCase))
{
objectClass = (string)hashTable[key];
Tracer.TraceInformation("got-objectclass {0}, {1}", objectClass, key);
continue;
}
if (key.Equals(Constants.ControlValues.DN, StringComparison.OrdinalIgnoreCase))
{
objectDN = (string)hashTable[key];
Tracer.TraceInformation("got-dn {0}, {1}", objectDN, key);
continue;
}
if (key.Equals(Constants.ControlValues.ChangeType, StringComparison.OrdinalIgnoreCase) || key.Equals(Constants.ControlValues.ChangeTypeEx, StringComparison.OrdinalIgnoreCase))
{
changeType = (string)hashTable[key];
Tracer.TraceInformation("got-changetype {0}, {1}", changeType, key);
continue;
}
if (key.Equals(Constants.ControlValues.ErrorName, StringComparison.OrdinalIgnoreCase))
{
ErrorName = (string)hashTable[key];
Tracer.TraceInformation("got-errorname {0}, {1}", ErrorName, key);
continue;
}
if (key.Equals(Constants.ControlValues.ErrorDetail, StringComparison.OrdinalIgnoreCase))
{
ErrorDetail = (string)hashTable[key];
Tracer.TraceInformation("got-errordetail {0}, {1}", ErrorDetail, key);
continue;
}
}
if (string.IsNullOrEmpty(objectClass))
{
Tracer.TraceError("missing-objectclass");
ImportErrorType = MAImportError.ImportErrorCustomContinueRun;
ErrorName = "missing-objectclass-value";
ErrorDetail = "No value provided for objectclass attribute";
}
else
{
AnchorAttributeName = objectTypeAnchorAttributeNames[objectClass] == null ? "" : (string)objectTypeAnchorAttributeNames[objectClass];
if (string.IsNullOrEmpty(AnchorAttributeName))
{
ImportErrorType = MAImportError.ImportErrorInvalidAttributeValue;
ErrorName = "invalid-objecttype";
ErrorDetail = "Objecttype not defined in schema";
}
foreach (string key in hashTable.Keys)
{
if (key.Equals(AnchorAttributeName, StringComparison.OrdinalIgnoreCase))
{
AnchorValue = hashTable[key];
Tracer.TraceInformation("got-anchor {0}, {1}", AnchorValue, key);
break;
}
}
}
Tracer.Unindent();
Tracer.TraceInformation("end-getting-control-values");
if (AnchorValue == null)
{
Tracer.TraceError("missing-anchor");
ImportErrorType = MAImportError.ImportErrorCustomContinueRun;
ErrorName = "missing-anchor-value";
ErrorDetail = "No value provided for anchor attribute";
}
if (AnchorValue != null && string.IsNullOrEmpty(objectDN))
{
Tracer.TraceInformation("setting-anchor-as-dn {0}", AnchorValue);
objectDN = AnchorValue.ToString();
}
if (!string.IsNullOrEmpty(ErrorName))
{
ImportErrorType = MAImportError.ImportErrorCustomContinueRun;
if (string.IsNullOrEmpty(ErrorDetail))
{
ErrorDetail = "No error details provided";
}
}
#endregion control values
#region return invalid object
if (ImportErrorType != MAImportError.Success)
{
Tracer.TraceInformation("returning-invalid-object");
if (AnchorValue != null)
{
csobject.AnchorAttributes.Add(AnchorAttribute.Create(AnchorAttributeName, AnchorValue));
}
csobject.ObjectModificationType = ObjectModificationType.Add;
if (!string.IsNullOrEmpty(objectClass))
{
try
{
csobject.ObjectType = objectClass;
}
catch (NoSuchObjectTypeException otEx)
{
Tracer.TraceError("no-such-object '{0}'", otEx);
}
}
if (!string.IsNullOrEmpty(objectClass))
{
csobject.DN = objectDN;
}
Tracer.TraceError("invalid-object dn: {0}, type: {1}, name: {2}, details: {3} ", objectDN, ImportErrorType, ErrorName, ErrorDetail);
csobject.ErrorCodeImport = ImportErrorType;
csobject.ErrorName = ErrorName;
csobject.ErrorDetail = ErrorDetail;
csentryqueue.Add(csobject);
continue;
}
#endregion
#region return deleted object
// we must set ObjectModificationType before any other attributes; otherwise it will default to 'Add'
if (!string.IsNullOrEmpty(changeType) && changeType.Equals("delete", StringComparison.OrdinalIgnoreCase))
{
Tracer.TraceInformation("returning-deleted-object");
Tracer.TraceInformation("change-type {0}", changeType);
csobject.ObjectModificationType = ObjectModificationType.Delete;
csobject.ObjectType = objectClass;
csobject.DN = objectDN;
// we need to get the object anchor value for the deletion
csobject.AnchorAttributes.Add(AnchorAttribute.Create(AnchorAttributeName, AnchorValue));
csentryqueue.Add(csobject);
continue;
}
#endregion
#region returned live object
Tracer.TraceInformation("returning-valid-object");
csobject.ObjectModificationType = ObjectModificationType.Add;
csobject.ObjectType = objectClass;
csobject.DN = objectDN;
csobject.AnchorAttributes.Add(AnchorAttribute.Create(AnchorAttributeName, AnchorValue));
foreach (string key in hashTable.Keys)
{
try
{
if (Regex.IsMatch(key, string.Format(@"^(objectClass|\[objectclass\]|changeType|\[changetype\]|\[DN\]|\[ErrorName\]|\[ErrorDetail\]|{0})$", AnchorAttributeName), RegexOptions.Compiled | RegexOptions.IgnoreCase))
{
Tracer.TraceInformation("skip-control-value {0}", key);
continue;
}
if (hashTable[key] == null)
{
Tracer.TraceInformation("skip-null-value-for '{0}'", key);
continue;
}
SchemaAttribute sa = schema.Types[objectClass].Attributes[key];
Tracer.TraceInformation("attribute: {0} (type {1}, {2}): '{3}'", key, sa.DataType, sa.IsMultiValued ? "multi-value" : "single-value", hashTable[key]);
if (sa.IsMultiValued)
{
//Tracer.TraceInformation("add-multivalue '{0}' [{1}]", key, hashTable[key].GetType());
List <object> mvs = new List <object>();
if (hashTable[key].ToString().EndsWith("[]"))
{
mvs.AddRange((object[])hashTable[key]);
}
else
{
mvs.Add(hashTable[key]);
}
csobject.AttributeChanges.Add(AttributeChange.CreateAttributeAdd(key, mvs));
}
else
{
csobject.AttributeChanges.Add(AttributeChange.CreateAttributeAdd(key, hashTable[key]));
}
}
catch (KeyNotFoundException keyexception)
{
Tracer.TraceError("attribute-is-not-defined-for '{0}' / '{1}' ({2})", key, objectClass, keyexception.ToString());
}
}
#endregion
if (csobject.ErrorCodeImport != MAImportError.Success)
{
Tracer.TraceError("defective-csentrychange id: {0}, dn: {1}, errorcode: {2}, error: {3}, details: {4}", csobject.Identifier, csobject.DN, csobject.ErrorCodeImport, csobject.ErrorName, csobject.ErrorDetail);
}
Tracer.TraceInformation("returning-csentry dn: {0}, id: {1}", csobject.DN, csobject.Identifier);
csentryqueue.Add(csobject);
}
catch (Exception ex)
{
Tracer.TraceError("creating-csentrychange", ex);
}
finally
{
Tracer.Unindent();
Tracer.TraceInformation("end-connector-space-object");
}
}
// clearing results for next loop
importResultsBatch.Clear();
}
#endregion
#region dequeue csentries
GetImportEntriesResults importReturnInfo = null;
Tracer.TraceInformation("total-import-object(s)-left {0:n0}", importResults.Count);
Tracer.TraceInformation("total-connector-space-object(s)-left {0:n0}", csentryqueue.Count);
List <CSEntryChange> batch = csentryqueue.Take(ImportRunStepPageSize).ToList();
if (csentryqueue.Count > ImportRunStepPageSize)
{
csentryqueue.RemoveRange(0, batch.Count);
}
else
{
csentryqueue.Clear();
}
importReturnInfo = new GetImportEntriesResults();
importReturnInfo.MoreToImport = MoreToImport || importResults.Count > 0 || (csentryqueue.Count > 0);
importReturnInfo.CustomData = returnedCustomData == null ? "" : returnedCustomData.ToString();
importReturnInfo.CSEntries = batch;
Tracer.TraceInformation("should-return-for-more {0}", importReturnInfo.MoreToImport);
Tracer.TraceInformation("custom-data '{0}'", importReturnInfo.CustomData);
Tracer.TraceInformation("connector-space-object(s)-returned {0:n0}", importReturnInfo.CSEntries.Count);
return(importReturnInfo);
#endregion
}
catch (Exception ex)
{
Tracer.TraceError("getimportentries", ex);
throw;
}
finally
{
Tracer.Unindent();
Tracer.Exit("getimportentries");
}
}
public OpenImportConnectionResults OpenImportConnection(System.Collections.ObjectModel.KeyedCollection <string, ConfigParameter> configParameters, Schema types, OpenImportConnectionRunStep openImportRunStep)
{
Tracer.IndentLevel = 0;
Tracer.Enter("openimportconnection");
Tracer.Indent();
try
{
Tracer.TraceInformation("getting-schema");
Tracer.Indent();
try
{
foreach (SchemaType type in types.Types)
{
foreach (SchemaAttribute attr in type.AnchorAttributes)
{
Tracer.TraceInformation("{0}-anchor-attribute {1} [{2}]", type.Name, attr.Name, attr.DataType);
objectTypeAnchorAttributeNames.Add(type.Name, attr.Name);
}
foreach (SchemaAttribute attr in type.Attributes)
{
Tracer.TraceInformation("{0}-attribute {1} [{2}]", type.Name, attr.Name, attr.DataType);
}
}
schema = types;
}
catch (Exception ex)
{
Tracer.TraceError("getting-schema", ex);
}
finally
{
Tracer.Unindent();
Tracer.TraceInformation("got-schema");
}
InitializeConfigParameters(configParameters);
//SetupImpersonationToken();
OpenRunspace();
Tracer.TraceInformation("resetting-pipeline-results-and-counters");
importResults = new List <PSObject>();
pageToken = "";
OpenImportConnectionResults oicr = new OpenImportConnectionResults();
ImportRunStepPageSize = openImportRunStep.PageSize;
Tracer.TraceInformation("openimportrunstep-pagesize '{0}'", ImportRunStepPageSize);
oicr.CustomData = openImportRunStep.ImportType == OperationType.Full ? "" : openImportRunStep.CustomData;
Tracer.TraceInformation("openimportrunstep-customdata '{0}'", oicr.CustomData);
importOperationType = openImportRunStep.ImportType;
Tracer.TraceInformation("openimportrunstep-importtype '{0}'", importOperationType);
return(oicr);
}
catch (Exception ex)
{
Tracer.TraceError("openimportconnection", ex);
throw;
}
finally
{
Tracer.Unindent();
Tracer.Exit("openimportconnection");
}
}
void OpenRunspace()
{
Tracer.Enter("openrunspace");
Tracer.Indent();
try
{
if (runspace == null)
{
Tracer.TraceInformation("creating-runspace");
runspace = RunspaceFactory.CreateRunspace();
runspace.ApartmentState = System.Threading.ApartmentState.STA;
runspace.ThreadOptions = PSThreadOptions.Default;
runspace.StateChanged += Runspace_StateChanged;
runspace.AvailabilityChanged += Runspace_AvailabilityChanged;
Tracer.TraceInformation("created-runspace");
}
else
{
Tracer.TraceInformation("existing-runspace-state '{0}'", runspace.RunspaceStateInfo.State);
}
if (runspace.RunspaceStateInfo.State == RunspaceState.BeforeOpen)
{
Tracer.TraceInformation("opening-runspace");
runspace.Open();
}
else
{
Tracer.TraceInformation("runspace-already-open");
}
Tracer.TraceInformation("runspace-state '{0}'", runspace.RunspaceStateInfo.State);
if (runspace.RunspaceStateInfo.State == RunspaceState.Opened)
{
Tracer.TraceInformation("runspace-powershell-version {0}.{1}", runspace.Version.Major, runspace.Version.Minor);
}
if (powershell == null)
{
Tracer.TraceInformation("creating-powershell");
powershell = PowerShell.Create();
powershell.Runspace = runspace;
Tracer.TraceInformation("powershell instanceid: {0}, runspace-id: {1}", powershell.InstanceId, powershell.Runspace.InstanceId);
Tracer.TraceInformation("powershell apartmentstate: {0}, version: {1}", powershell.Runspace.ApartmentState, powershell.Runspace.Version);
// the streams (Error, Debug, Progress, etc) are available on the PowerShell instance.
// we can review them during or after execution.
// we can also be notified when a new item is written to the stream (like this):
powershell.Streams.ClearStreams();
powershell.Streams.Error.DataAdded += new EventHandler <DataAddedEventArgs>(Error_DataAdded);
powershell.Streams.Verbose.DataAdded += new EventHandler <DataAddedEventArgs>(Verbose_DataAdded);
powershell.Streams.Warning.DataAdded += new EventHandler <DataAddedEventArgs>(Warning_DataAdded);
powershell.Streams.Debug.DataAdded += new EventHandler <DataAddedEventArgs>(Debug_DataAdded);
powershell.Streams.Progress.DataAdded += new EventHandler <DataAddedEventArgs>(Progress_DataAdded);
Tracer.TraceInformation("created-powershell");
}
}
catch (Exception ex)
{
Tracer.TraceError("openrunspace", ex);
throw;
}
finally
{
Tracer.Unindent();
Tracer.Exit("openrunspace");
}
}
public void InitializeConfigParameters(System.Collections.ObjectModel.KeyedCollection <string, ConfigParameter> configParameters)
{
Tracer.Enter("initializeconfigparameters");
Tracer.Indent();
try
{
if (configParameters != null)
{
foreach (ConfigParameter cp in configParameters)
{
Tracer.TraceInformation("{0}: '{1}'", cp.Name, cp.IsEncrypted ? "*** secret ***" : cp.Value);
if (cp.Name.Equals(Constants.Parameters.Username))
{
Username = configParameters[cp.Name].Value;
}
if (cp.Name.Equals(Constants.Parameters.Password))
{
Password = configParameters[cp.Name].SecureValue.ConvertToUnsecureString();
SecureStringPassword = configParameters[cp.Name].SecureValue;
}
if (cp.Name.Equals(Constants.Parameters.ImpersonationDomain))
{
impersonationUserDomain = configParameters[cp.Name].Value;
}
if (cp.Name.Equals(Constants.Parameters.ImpersonationUsername))
{
impersonationUsername = configParameters[cp.Name].Value;
}
if (cp.Name.Equals(Constants.Parameters.ImpersonationPassword))
{
impersonationUserPassword = configParameters[cp.Name].SecureValue.ConvertToUnsecureString();
}
if (cp.Name.Equals(Constants.Parameters.SchemaScript))
{
SchemaScript = configParameters[cp.Name].Value;
}
if (cp.Name.Equals(Constants.Parameters.ImportScript))
{
ImportScript = configParameters[cp.Name].Value;
}
if (cp.Name.Equals(Constants.Parameters.ExportScript))
{
ExportScript = configParameters[cp.Name].Value;
}
if (cp.Name.Equals(Constants.Parameters.PasswordManagementScript))
{
PasswordManagementScript = configParameters[cp.Name].Value;
}
if (cp.Name.Equals(Constants.Parameters.ExportSimpleObjects))
{
ExportSimpleObjects = configParameters[cp.Name].Value == "0" ? false : true;
}
if (cp.Name.Equals(Constants.Parameters.UsePagedImport))
{
UsePagedImport = configParameters[cp.Name].Value == "0" ? false : true;
}
}
}
}
catch (Exception ex)
{
Tracer.TraceError("initializeconfigparameters", ex);
throw;
}
finally
{
Tracer.Unindent();
Tracer.Exit("initializeconfigparameters");
}
}
