public void EnsureBackwardsCompatibility() { if (this.RenameDnFlow != null) { Tracer.TraceWarning("'RenameDnFlow' is no longer supported. Use 'ConditionalRename' instead' or remove 'RenameDnFlow' element from rule definition (see documentation)."); } switch (this.Action) { case RuleAction.provision: this.Action = RuleAction.Provision; Tracer.TraceWarning("Lowercase 'provision' action keyword is deprecated. Use 'Provision' instead' (see documentation)."); break; case RuleAction.deprovision: this.Action = RuleAction.Deprovision; Tracer.TraceWarning("Lowercase 'deprovision' action keyword is deprecated. Use 'Deprovision' instead' (see documentation)."); break; case RuleAction.rename: this.Action = RuleAction.Rename; Tracer.TraceWarning("Lowercase 'rename' action keyword is deprecated. Use 'Rename' instead' (see documentation)."); break; case RuleAction.deprovisionall: this.Action = RuleAction.DeprovisionAll; Tracer.TraceWarning("Lowercase 'deprovisionall' action keyword is deprecated. Use 'DeprovisionAll' instead' (see documentation)."); break; default: break; } }
object GetSafeValue(DataRow dataRow, string attributeName, AttributeType attributeType, bool DeltaDate = false) { object value = null; try { if (dataRow.IsNull(attributeName)) { return(null); } switch (attributeType) { case AttributeType.Binary: value = dataRow.Field <object>(attributeName); if (value.GetType().Equals(typeof(System.Guid))) { value = ((Guid)value).ToByteArray(); } return(value); case AttributeType.Reference: // reference is always string in FIM value = dataRow.Field <object>(attributeName); return(value.ToString()); case AttributeType.String: if (DeltaDate) { value = dataRow.Field <object>(attributeName); return(value); } else { value = dataRow.Field <object>(attributeName); if (IsDateTimeType(value.GetType())) { DateTime dt; if (DateTime.TryParse(value.ToString(), out dt)) { value = dt.ToString(Configuration.DateFormat); return(value); } else { Tracer.TraceWarning("unable-to-parse-value-to-date: value: {0}", value); } } return(value.ToString()); } default: value = dataRow.Field <object>(attributeName); return(value); } } catch (Exception e) { Tracer.TraceError($"{nameof(GetSafeValue)}, attribute: {attributeName}, target-type: {attributeType}, value: {value}, error: {e.Message}"); throw; } }
public override bool Met(MVEntry mventry, CSEntry csentry) { if (!mventry[this.MVAttributeStartDate].IsPresent) { Tracer.TraceInformation("Condition failed (Reason: MVAttributeStartDate {0} attribute value is not present) / {0}", this.MVAttributeStartDate, this.Description); return(false); } if (!mventry[this.MVAttributeEndDate].IsPresent) { Tracer.TraceInformation("Condition failed (Reason: MVAttributeEndDate {0} attribute value is not present) / {0}", this.MVAttributeEndDate, this.Description); return(false); } DateTime startDate; DateTime endDate; if (!DateTime.TryParse(mventry[this.MVAttributeStartDate].StringValue, out startDate)) { Tracer.TraceWarning("unable-to-parse-start-mvvalue-to-datetime {0}", mventry[this.MVAttributeStartDate].StringValue); return(false); } if (!DateTime.TryParse(mventry[this.MVAttributeEndDate].StringValue, out endDate)) { Tracer.TraceWarning("unable-to-parse-end-mvvalue-to-datetime {0}", mventry[this.MVAttributeEndDate].StringValue); return(false); } DateTime now = DateTime.Now; bool returnValue = (startDate < now) && (now < endDate); Tracer.TraceInformation("compare-dates now: {0}, start: {1}, end: {2}, is-between: {3}", now, startDate, endDate, returnValue); return(returnValue); }
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"); } }
public override bool Met(MVEntry mventry, CSEntry csentry) { Tracer.TraceWarning("Condition type 'ConditionAttributeIsNotPresent' is obsolete. Please see documentation."); if (!mventry[this.MVAttribute].IsPresent) { return(true); } else { Tracer.TraceInformation("Condition failed (Reason: Metaverse attribute value is present) {0}", this.Description); return(false); } }
void InvokeExternalMethod(string ExternalReferenceId, ExternalType Type, MVEntry mventry, CSEntry csentry) { if (!string.IsNullOrEmpty(ExternalReferenceId) && Externals.ContainsKey(ExternalReferenceId)) { External external = Externals[ExternalReferenceId]; if (external != null) { if (Type == ExternalType.Provision) { external.Provision(mventry); } else if (Type == ExternalType.ShouldDeleteFromMV) { external.ShouldDeleteFromMV(csentry, mventry); } } else { Tracer.TraceWarning("no-external-reference-found-for-referenceid {0}", ExternalReferenceId); } } }
public override bool Met(MVEntry mventry, CSEntry csentry) { if (mventry[this.MVAttribute].IsPresent) { DateTime value; if (DateTime.TryParse(mventry[this.MVAttribute].StringValue, out value)) { DateTime now = DateTime.Now; bool returnValue = now > value; Tracer.TraceInformation("compare-dates now: {0}, mvvalue: {1}, is-after: {2}", now, value, returnValue); return(returnValue); } else { Tracer.TraceWarning("unable-to-parse-mvvalue-to-datetime {0}", mventry[this.MVAttribute].StringValue); return(false); } } else { Tracer.TraceInformation("Condition failed (Reason: Metaverse attribute value is not present) {0}", this.Description); return(false); } }
public GetImportEntriesResults GetImportEntries(GetImportEntriesRunStep importRunStep) { Tracer.Enter("getimportentries"); 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("Username", Username)); cmd.Parameters.Add(new CommandParameter("Password", Password)); cmd.Parameters.Add(new CommandParameter("Credentials", GetSecureCredentials(Username, SecureStringPassword))); cmd.Parameters.Add(new CommandParameter("AuxUsername", UsernameAux)); cmd.Parameters.Add(new CommandParameter("AuxPassword", PasswordAux)); cmd.Parameters.Add(new CommandParameter("AuxCredentials", GetSecureCredentials(UsernameAux, SecureStringPasswordAux))); cmd.Parameters.Add(new CommandParameter("ConfigurationParameter", ConfigurationParameter)); cmd.Parameters.Add(new CommandParameter("OperationType", importOperationType.ToString())); cmd.Parameters.Add(new CommandParameter("UsePagedImport", UsePagedImport)); cmd.Parameters.Add(new CommandParameter("PageSize", ImportRunStepPageSize)); cmd.Parameters.Add(new CommandParameter("Schema", schemaPSObject)); 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"); try { CSEntryChange csobject = CSEntryChange.Create(); if (obj.BaseObject.GetType() != typeof(System.Collections.Hashtable)) { Tracer.TraceWarning("invalid-object-in-pipeline '{0}'", 1, 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"); 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.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.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.Exit("getimportentries"); } }
public void Initialize() { Tracer.TraceInformation("enter-initialize"); try { System.Reflection.Assembly assembly = System.Reflection.Assembly.GetExecutingAssembly(); FileVersionInfo fvi = FileVersionInfo.GetVersionInfo(assembly.Location); Tracer.TraceInformation("fim-mre-version {0}", fvi.FileVersion); RegistryKey machineRegistry = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry64); RegistryKey mreRootKey = machineRegistry.OpenSubKey(@"SOFTWARE\Granfeldt\FIM\MRE", false); if (mreRootKey != null) { string logFileValue = mreRootKey.GetValue("DebugLogFileName", null) as string; if (logFileValue != null) { Tracer.TraceWarning("DebugLogFileName registry key is deprecated. Use trace logging instead."); } string ruleFilesAlternativePath = mreRootKey.GetValue("RuleFilesAlternativePath", null) as string; if (!string.IsNullOrEmpty(ruleFilesAlternativePath)) { ruleFilesPath = ruleFilesAlternativePath; Tracer.TraceInformation("registry-alternative-rulefiles-path '{0}'", ruleFilesPath); } } if (!EventLog.SourceExists(EventLogSource)) { Tracer.TraceInformation("creating-eventlog-source source: {0}, logname: ", EventLogSource, EventLogName); EventLog.CreateEventSource(EventLogSource, EventLogName); } 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 DEBUG // for debugging, we use current path if (ruleFilesPath == Utils.ExtensionsDirectory) { ruleFilesPath = Directory.GetCurrentDirectory(); } #endif Tracer.TraceInformation("loading-rule-files-from '{0}'", ruleFilesPath); this.EngineRules = new Dictionary <string, List <Rule> >(); this.Externals = new Dictionary <string, External>(); string[] ruleFiles = Directory.GetFiles(ruleFilesPath, "*.mre.xml", SearchOption.AllDirectories); foreach (string ruleFile in ruleFiles) { RulesFile rules = new RulesFile(); Tracer.TraceInformation("loading-rule-file '{0}'", ruleFile); MVRules.LoadSettingsFromFile(ruleFile, ref rules); foreach (Rule rule in rules.Rules) { if (rule.Enabled) { Tracer.TraceInformation("found-active-rule {0}", rule.Name); } else { Tracer.TraceInformation("found-inactive-rule {0}", rule.Name); continue; } rule.EnsureBackwardsCompatibility(); if (rule.Enabled && rule.RenameDnFlow != null) { Tracer.TraceWarning("RenameDnFlow XML element is obsolete and will not be supported in coming versions. Please see documentation for more information."); } if (!this.EngineRules.ContainsKey(rule.SourceObject)) { this.EngineRules.Add(rule.SourceObject, new List <Rule>()); } this.EngineRules[rule.SourceObject].Add(rule); } // handle loading externals foreach (External e in rules.Externals) { if (string.IsNullOrEmpty(e.ReferenceId)) { Tracer.TraceWarning("skipping-external-without-referenceid-value"); continue; } if (!this.Externals.ContainsKey(e.ReferenceId)) { Tracer.TraceInformation("external referenceid: {0}, type: {1}, filename: {2}", e.ReferenceId, e.Type, e.Filename); e.EnsureFullFilename(ruleFilesPath); e.LoadExternalAssembly(); this.Externals.Add(e.ReferenceId, e); foreach (External i in Externals?.Values) { i.Initialize(); } } else { Tracer.TraceError("cannot-add-duplicate-external-referenceid-value {0}", e.ReferenceId); } } } if (this.EngineRules.Count == 0) { Tracer.TraceWarning("no-rules-loaded"); } } catch (Exception ex) { Tracer.TraceError("error {0}", ex.GetBaseException()); throw; } finally { Tracer.TraceInformation("exit-initialize"); } }
static void Warning_DataAdded(object sender, DataAddedEventArgs e) { Tracer.TraceWarning("warning {0}", ((PSDataCollection <WarningRecord>)sender)[e.Index].ToString()); }
public void InitializeConfigParameters(System.Collections.ObjectModel.KeyedCollection <string, ConfigParameter> configParameters) { Tracer.Enter("initializeconfigparameters"); 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.UsernameAux)) { UsernameAux = configParameters[cp.Name].Value; } if (cp.Name.Equals(Constants.Parameters.PasswordAux)) { PasswordAux = configParameters[cp.Name].SecureValue.ConvertToUnsecureString(); SecureStringPasswordAux = configParameters[cp.Name].SecureValue; } if (cp.Name.Equals(Constants.Parameters.ConfigurationParameters)) { string[] result = Regex.Split(configParameters[cp.Name].Value, "\r\n|\r|\n"); if (result != null) { foreach (string s in result) { string key = null; string value = null; if (getConfigurationParameter(s, out key, out value)) { Tracer.TraceInformation($"configuration-parameter key: '{key}', value: '{value}'"); if (ConfigurationParameter.ContainsKey(key)) { Tracer.TraceWarning($"duplicate-configuration key: {key}"); } else { ConfigurationParameter.Add(key, value); } } } } } 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.Exit("initializeconfigparameters"); } }
public AttributeDefinition(string Name, string DataTypeName) { this.Name = Name; AttributeOperation = AttributeOperation.ImportExport; switch (DataTypeName) { case "int": this.AttributeType = AttributeType.Integer; break; case "bigint": this.AttributeType = AttributeType.Integer; break; case "tinyint": this.AttributeType = AttributeType.Integer; break; case "smallint": this.AttributeType = AttributeType.Integer; break; case "bit": this.AttributeType = AttributeType.Boolean; break; case "binary": this.AttributeType = AttributeType.Binary; break; case "varbinary": this.AttributeType = AttributeType.Binary; break; case "image": this.AttributeType = AttributeType.Binary; break; case "uniqueidentifier": this.AttributeType = AttributeType.Binary; break; case "date": this.AttributeType = AttributeType.String; break; case "datetime": this.AttributeType = AttributeType.String; break; case "smalldatetime": this.AttributeType = AttributeType.String; break; case "datetime2": this.AttributeType = AttributeType.String;; break; case "datetimeoffset": this.AttributeType = AttributeType.String; break; case "time": this.AttributeType = AttributeType.String; break; case "timestamp": this.AttributeType = AttributeType.String; AttributeOperation = AttributeOperation.ImportOnly; break; case "nvarchar": this.AttributeType = AttributeType.String; break; case "char": this.AttributeType = AttributeType.String; break; case "varchar": this.AttributeType = AttributeType.String; break; case "text": this.AttributeType = AttributeType.String; break; case "nchar": this.AttributeType = AttributeType.String; break; case "ntext": this.AttributeType = AttributeType.String; break; case "decimal": this.AttributeType = AttributeType.String; break; case "float": this.AttributeType = AttributeType.String; break; case "money": this.AttributeType = AttributeType.String; break; case "smallmoney": this.AttributeType = AttributeType.String; break; case "real": this.AttributeType = AttributeType.String; break; case "xml": this.AttributeType = AttributeType.String; break; default: Tracer.TraceWarning("non-supported-type name: {0}, sql-type: {1}", Name, DataTypeName); this.AttributeType = AttributeType.String; break; } Tracer.TraceInformation("name: {0}, sql-type: {1}, selected-schematype: {2}", Name, DataTypeName, AttributeType); }