private void LogRemoveMailboxDetails(ADUser recipient)
{
Guid uniqueId = base.CurrentTaskContext.UniqueId;
CmdletLogger.SafeAppendGenericInfo(uniqueId, "ExchangeGuid", recipient.ExchangeGuid.ToString());
CmdletLogger.SafeAppendGenericInfo(uniqueId, "HomeMBD", (recipient.Database == null) ? string.Empty : recipient.Database.ToString());
}
// Token: 0x06001673 RID: 5747 RVA: 0x00054EB4 File Offset: 0x000530B4
private void MarkDcDownIfNecessary(GenericEventArg <TaskErrorEventArg> e)
{
if (e.Data.ExceptionHandled)
{
return;
}
ADDriverContext threadADContext = ADSessionSettings.GetThreadADContext();
ADServerSettings adserverSettings = (threadADContext != null) ? threadADContext.ServerSettings : null;
if (this.context == null || adserverSettings == null)
{
return;
}
string text = null;
for (Exception ex = e.Data.Exception; ex != null; ex = ex.InnerException)
{
if (ex is SuitabilityDirectoryException)
{
text = ((SuitabilityDirectoryException)ex).Fqdn;
break;
}
if (ex is ServerInMMException)
{
text = ((ServerInMMException)ex).Fqdn;
break;
}
if (ex is ADServerSettingsChangedException)
{
ADServerSettings serverSettings = ((ADServerSettingsChangedException)ex).ServerSettings;
this.PersistNewServerSettings(serverSettings);
break;
}
if (ex == ex.InnerException)
{
break;
}
}
if (string.IsNullOrWhiteSpace(text))
{
return;
}
Fqdn fqdn;
if (Fqdn.TryParse(text, out fqdn))
{
try
{
adserverSettings.MarkDcDown(fqdn);
CmdletLogger.SafeAppendGenericInfo(this.context.UniqueId, "MarkDcDown", fqdn);
return;
}
catch (NotSupportedException)
{
CmdletLogger.SafeAppendGenericInfo(this.context.UniqueId, "MarkDcDown-NotSupportedException", fqdn);
return;
}
}
CmdletLogger.SafeAppendGenericInfo(this.context.UniqueId, "MarkDcDown-InvalidFqdn", fqdn);
}
protected void EnforceDelay()
{
if (this.context.ErrorInfo.TerminatePipeline)
{
return;
}
IPowerShellBudget psbudget = this.PSBudget;
if (psbudget != null)
{
T t = (default(T) == null) ? Activator.CreateInstance <T>() : default(T);
DelayEnforcementResults delayEnforcementResults = t.EnforceDelay(this, ThrottlingModule <T> .costTypesInEnforceDelay, ThrottlingModule <T> .CmdletMaxPreferredDelay);
LocalizedString localizedString = this.GenerateDelayInfoLogString(this.PSBudget, delayEnforcementResults);
if (!string.IsNullOrEmpty(localizedString))
{
string text = string.Format("; PolicyDN: {0}; Snapshot: {1}", psbudget.ThrottlingPolicy.GetIdentityString(), psbudget);
LocalizedString warningMessage = new LocalizedString(localizedString + text);
this.context.Items["ThrottlingInfo"] = text;
this.context.Items["DelayedInfo"] = localizedString;
Guid uniqueId = this.context.UniqueId;
CmdletLogger.SafeSetLogger(uniqueId, RpsCmdletMetadata.ThrottlingInfo, text);
CmdletLogger.SafeSetLogger(uniqueId, RpsCmdletMetadata.DelayInfo, CmdletLogHelper.NeedConvertLogMessageToUS ? localizedString.ToString(CmdletLogHelper.DefaultLoggingCulture) : localizedString);
this.WriteCmdletMicroDelayMessage(warningMessage, delayEnforcementResults.DelayInfo.Delay.TotalSeconds);
}
PowerShellBudgetWrapper powerShellBudgetWrapper = psbudget as PowerShellBudgetWrapper;
WorkloadManagementLogger.SetBudgetBalance(powerShellBudgetWrapper.GetInnerBudget().CasTokenBucket.GetBalance().ToString(), null);
}
}
// Token: 0x060015BC RID: 5564 RVA: 0x00050BCF File Offset: 0x0004EDCF
public override bool WriteObject(object input, out object output)
{
output = input;
this.outputObjectCount++;
CmdletLogger.SafeSetLogger(this.context.UniqueId, RpsCmdletMetadata.OutputObjectCount, this.outputObjectCount);
return(true);
}
internal void NewGroupMailbox(DatabaseLocationInfo databaseLocationInfo, out Exception exception, out ExchangeErrorCategory?errorCategory)
{
errorCategory = null;
try
{
this.AddVerboseLog("Start: NewGroupMailbox");
this.EnsureGroupIsInDirectoryCache("GroupMailboxContext.NewGroupMailbox");
this.UpdateGroupMailbox(databaseLocationInfo, (GroupMailboxConfigurationActionType)0, this.GetValidGroupMembersFromFromRecipientIds(this.setMembers), null);
if (this.invalidUsers.Length > 0)
{
CmdletLogger.SafeAppendGenericError("UsersWithoutSmtpAddress_New", this.invalidUsers.ToString(), false);
this.invalidUsers.Clear();
}
exception = null;
}
catch (Exception ex)
{
exception = ex;
errorCategory = new ExchangeErrorCategory?(ExchangeErrorCategory.ServerTransient);
if (this.IsWellKnownClientException(ex))
{
errorCategory = new ExchangeErrorCategory?(ExchangeErrorCategory.Client);
}
}
finally
{
this.AddVerboseLog("End: NewGroupMailbox");
}
}
internal void SetGroupMailbox(GroupMailboxConfigurationActionType forceConfigurationActionMask, out Exception exception, out ExchangeErrorCategory?errorCategory)
{
errorCategory = null;
try
{
this.AddVerboseLog("Start: SetGroupMailbox");
if (this.addMembers != null || this.removeMembers != null || !this.groupMailbox.IsGroupMailboxConfigured || this.permissionsVersion != null || forceConfigurationActionMask != (GroupMailboxConfigurationActionType)0)
{
this.UpdateGroupMailbox(null, forceConfigurationActionMask, this.GetValidGroupMembersFromFromRecipientIds(this.addMembers), this.ResolveUsers(this.removeMembers, new Action <RecipientIdParameter, Exception>(this.ReportResolveUserWarning)));
if (this.invalidUsers.Length > 0)
{
CmdletLogger.SafeAppendGenericError("UsersWithoutSmtpAddress_Set", this.invalidUsers.ToString(), false);
this.invalidUsers.Clear();
}
}
else
{
this.AddVerboseLog("No members to update on GroupMailbox or configuration action to execute.");
}
exception = null;
}
catch (LocalizedException ex)
{
exception = ex;
errorCategory = new ExchangeErrorCategory?(ExchangeErrorCategory.ServerTransient);
if (this.IsWellKnownClientException(ex))
{
errorCategory = new ExchangeErrorCategory?(ExchangeErrorCategory.Client);
}
}
finally
{
this.AddVerboseLog("End: SetGroupMailbox");
}
}
internal static void Execute(this ICriticalFeature feature, Action action, TaskContext taskContext, string methodNameInLog)
{
try
{
action();
}
catch (Exception ex)
{
Guid uniqueId = taskContext.UniqueId;
bool flag = false;
Exception ex2;
bool needReportException = !TaskHelper.IsTaskKnownException(ex2) && TaskHelper.ShouldReportException(ex2, out flag);
if (!needReportException)
{
CmdletLogger.SafeAppendGenericError(uniqueId, methodNameInLog, ex2.ToString(), false);
}
else
{
CmdletLogger.SafeAppendGenericError(uniqueId, methodNameInLog, ex2.ToString(), true);
CmdletLogger.SafeSetLogger(uniqueId, RpsCmdletMetadata.ErrorType, "UnHandled");
}
if (feature == null || feature.IsCriticalException(ex2))
{
throw;
}
if (!flag)
{
taskContext.CommandShell.WriteWarning(Strings.WarningTaskModuleSkipped(methodNameInLog, ex2.Message));
}
Diagnostics.ReportException(ex2, Constants.CoreEventLogger, TaskEventLogConstants.Tuple_UnhandledException, (object ex) => needReportException, null, ExTraceGlobals.InstrumentationTracer, "Exception from " + methodNameInLog + ": {0}");
}
}
// Token: 0x06001640 RID: 5696 RVA: 0x00053918 File Offset: 0x00051B18
private void OnPreIterate(object sender, EventArgs eventArgs)
{
this.shouldProcessHasBeenPrompted = false;
this.proxiedObjectCount = 0;
CmdletLogger.SafeSetLogger(this.context.UniqueId, RpsCmdletMetadata.ProxiedObjectCount, 0);
this.context.Items["Log_ProxiedObjectCount"] = 0;
}
// Token: 0x06001675 RID: 5749 RVA: 0x00055040 File Offset: 0x00053240
private void PersistNewServerSettings(ADServerSettings newServerSettings)
{
if (newServerSettings != null)
{
ADSessionSettings.ClearThreadADContext();
LocalizedString adserverSettings;
if (CmdletLogHelper.NeedConvertLogMessageToUS)
{
adserverSettings = TaskVerboseStringHelper.GetADServerSettings(this.context.InvocationInfo.CommandName, newServerSettings, CmdletLogHelper.DefaultLoggingCulture);
}
else
{
adserverSettings = TaskVerboseStringHelper.GetADServerSettings(this.context.InvocationInfo.CommandName, newServerSettings);
}
if (this.context.SessionState != null)
{
CmdletLogger.SafeAppendGenericInfo(this.context.UniqueId, "ADServerSettings-FailOver", adserverSettings);
ExchangePropertyContainer.SetServerSettings(this.context.SessionState, newServerSettings);
}
else
{
CmdletLogger.SafeAppendGenericInfo(this.context.UniqueId, "ADServerSettings-NOTFailOver-SessionStateNull", adserverSettings);
}
ADSessionSettings.SetThreadADContext(new ADDriverContext(newServerSettings, ContextMode.Cmdlet));
this.context.ServerSettingsAfterFailOver = newServerSettings;
this.context.CommandShell.WriteWarning(DirectoryStrings.RunspaceServerSettingsChanged);
return;
}
CmdletLogger.SafeAppendGenericInfo(this.context.UniqueId, "ADServerSettings-NOTFailOver-ServerSettingsNull", "NULL");
}
// Token: 0x06001642 RID: 5698 RVA: 0x000539C4 File Offset: 0x00051BC4
private bool ProxyCmdlet(CmdletProxyInfo cmdletProxyInfo)
{
this.proxiedObjectCount++;
CmdletLogger.SafeSetLogger(this.context.UniqueId, RpsCmdletMetadata.ProxiedObjectCount, this.proxiedObjectCount);
this.context.Items["Log_ProxiedObjectCount"] = this.proxiedObjectCount;
if (cmdletProxyInfo.ConfirmationMessage != LocalizedString.Empty)
{
if (!this.shouldProcessHasBeenPrompted && this.context.CommandShell != null && !this.context.CommandShell.ShouldProcess(cmdletProxyInfo.ConfirmationMessage))
{
CmdletLogger.SafeAppendGenericInfo(this.context.UniqueId, "Proxy", "CancelAfterConfirm");
CmdletLogger.SafeSetLogger(this.context.UniqueId, RpsCmdletMetadata.ExecutionResult, "Cancelled");
this.context.WasCancelled = true;
return(false);
}
SwitchParameter switchParameter = new SwitchParameter(false);
if (this.ShouldRemoveConfirmParam() && this.context.InvocationInfo != null)
{
this.context.InvocationInfo.UserSpecifiedParameters.Remove("Confirm");
}
if (this.context.InvocationInfo != null)
{
this.context.InvocationInfo.UserSpecifiedParameters.Add("Confirm", switchParameter);
}
}
using (new CmdletMonitoredScope(this.context.UniqueId, "CmdletProxyLatency", "CmdletProxyLatency", LoggerHelper.CmdletPerfMonitors))
{
this.ProxyCmdletExecution(cmdletProxyInfo);
}
this.context.Items["Log_CmdletProxyInfo"] = string.Format("Cmdlet proxied to remote server {0}, version {1}.", cmdletProxyInfo.RemoteServerFqdn, ProxyHelper.GetFriendlyVersionInformation(cmdletProxyInfo.RemoteServerVersion));
return(true);
}
internal void TriggerFailFast(OverBudgetException cmdletOverBudget)
{
if (this.context.UserInfo.ExecutingWindowsLiveId.IsValidAddress)
{
FailFastUserCache.Instance.AddUserToCache(this.context.UserInfo.ExecutingWindowsLiveId.ToString(), BlockedType.NewRequest, (cmdletOverBudget == null) ? TimeSpan.Zero : new TimeSpan(0, 0, 0, 0, cmdletOverBudget.BackoffTime));
CmdletLogger.SafeAppendColumn(this.context.UniqueId, RpsCmdletMetadata.ContributeToFailFast, "Cmdlet", LoggerHelper.GetContributeToFailFastValue("User", this.context.UserInfo.ExecutingUserId.ToString(), "NewRequest", (double)((cmdletOverBudget == null) ? -1 : cmdletOverBudget.BackoffTime)));
}
}
// Token: 0x06001603 RID: 5635 RVA: 0x00052250 File Offset: 0x00050450
private void OnIterateCompleted(object sender, EventArgs eventArgs)
{
if (this.context.InvocationInfo != null)
{
Guid uniqueId = this.context.UniqueId;
this.parametersSetInLog = true;
CmdletLogger.SafeSetLogger(uniqueId, RpsCmdletMetadata.Cmdlet, this.context.InvocationInfo.CommandName);
CmdletLogger.SafeSetLogger(uniqueId, RpsCmdletMetadata.Parameters, TaskVerboseStringHelper.FormatUserSpecifiedParameters(this.context.InvocationInfo.UserSpecifiedParameters ?? new PropertyBag()));
}
}
internal static void SetCmdletErrorType(Guid cmdletUniqueId, string errorType)
{
string a = CmdletStaticDataWithUniqueId <string> .Get(cmdletUniqueId);
if (a == "UnHandled")
{
return;
}
CmdletStaticDataWithUniqueId <string> .Set(cmdletUniqueId, errorType);
CmdletLogger.SafeSetLogger(cmdletUniqueId, RpsCmdletMetadata.ErrorType, errorType);
}
// Token: 0x06001607 RID: 5639 RVA: 0x00052434 File Offset: 0x00050634
private void StartLogging()
{
this.logPendingCommit = true;
this.parametersSetInLog = false;
Guid uniqueId = this.context.UniqueId;
CmdletThreadStaticData.RegisterCmdletUniqueId(uniqueId);
CmdletLogger.SafeSetLogger(uniqueId, RpsCmdletMetadata.StartTime, DateTime.UtcNow);
CmdletLogger.SafeSetLogger(uniqueId, RpsCmdletMetadata.ExecutionResult, "Success");
CmdletLatencyTracker.StartLatencyTracker(uniqueId);
CmdletLatencyTracker.StartInternalTracking(uniqueId, "Cmd", true);
}
private LocalizedString GenerateDelayInfoLogString(IBudget budget, DelayEnforcementResults info)
{
LocalizedString result = LocalizedString.Empty;
if (!string.Equals(info.NotEnforcedReason, "No Delay Necessary", StringComparison.OrdinalIgnoreCase))
{
CmdletLogger.SafeAppendGenericInfo(this.context.UniqueId, "DelayInfo.Type", info.DelayInfo.GetType().Name);
if (info.NotEnforcedReason != null)
{
CmdletLogger.SafeAppendGenericInfo(this.context.UniqueId, "NotEnforcedReason", info.NotEnforcedReason);
}
if (string.Equals(info.NotEnforcedReason, "Max Delayed Threads Exceeded", StringComparison.OrdinalIgnoreCase))
{
BudgetTypeSetting budgetTypeSetting = BudgetTypeSettings.Get(budget.Owner.BudgetType);
if (info.DelayInfo is UserQuotaDelayInfo)
{
UserQuotaDelayInfo userQuotaDelayInfo = info.DelayInfo as UserQuotaDelayInfo;
result = Strings.UserQuotaDelayNotEnforcedMaxThreadsExceeded((int)info.DelayInfo.Delay.TotalMilliseconds, info.DelayInfo.Required, userQuotaDelayInfo.OverBudgetException.PolicyPart, budgetTypeSetting.MaxDelayedThreads);
}
else if (info.DelayInfo is ResourceLoadDelayInfo)
{
ResourceLoadDelayInfo resourceLoadDelayInfo = info.DelayInfo as ResourceLoadDelayInfo;
result = Strings.ResourceLoadDelayNotEnforcedMaxThreadsExceeded((int)info.DelayInfo.Delay.TotalMilliseconds, info.DelayInfo.Required, resourceLoadDelayInfo.ResourceKey.ToString(), resourceLoadDelayInfo.ResourceLoad.ToString(), budgetTypeSetting.MaxDelayedThreads);
}
else
{
result = Strings.MicroDelayNotEnforcedMaxThreadsExceeded((int)info.DelayInfo.Delay.TotalMilliseconds, info.DelayInfo.Required, budgetTypeSetting.MaxDelayedThreads);
}
}
else
{
CmdletLogger.SafeSetLogger(this.context.UniqueId, RpsCmdletMetadata.ThrottlingDelay, info.DelayedAmount.TotalMilliseconds);
if (info.DelayInfo is UserQuotaDelayInfo)
{
UserQuotaDelayInfo userQuotaDelayInfo2 = info.DelayInfo as UserQuotaDelayInfo;
result = Strings.UserQuotaDelayInfo((int)info.DelayedAmount.TotalMilliseconds, info.Enforced, (int)info.DelayInfo.Delay.TotalMilliseconds, info.DelayInfo.Required, userQuotaDelayInfo2.OverBudgetException.PolicyPart, info.NotEnforcedReason);
}
else if (info.DelayInfo is ResourceLoadDelayInfo)
{
ResourceLoadDelayInfo resourceLoadDelayInfo2 = info.DelayInfo as ResourceLoadDelayInfo;
result = Strings.ResourceLoadDelayInfo((int)info.DelayedAmount.TotalMilliseconds, info.Enforced, (int)info.DelayInfo.Delay.TotalMilliseconds, info.DelayInfo.Required, resourceLoadDelayInfo2.ResourceKey.ToString(), resourceLoadDelayInfo2.ResourceLoad.ToString(), info.NotEnforcedReason);
}
else
{
result = Strings.MicroDelayInfo((int)info.DelayedAmount.TotalMilliseconds, info.Enforced, (int)info.DelayInfo.Delay.TotalMilliseconds, info.DelayInfo.Required, info.NotEnforcedReason);
}
}
}
return(result);
}
internal static void LogADServerSettingsAfterCmdExecuted(Guid cmdletUniqueId, ADServerSettings serverSettings)
{
string key = "ADServerSettingsInEnd";
StringBuilder stringBuilder = new StringBuilder();
string format = "{0}:{1} ";
if (serverSettings == null)
{
CmdletLogger.SafeAppendGenericInfo(cmdletUniqueId, key, "null");
return;
}
stringBuilder.AppendFormat(format, RpsCmdletMetadata.ADViewEntireForest.ToString(), serverSettings.ViewEntireForest);
if (serverSettings.RecipientViewRoot != null)
{
stringBuilder.AppendFormat(format, RpsCmdletMetadata.ADRecipientViewRoot.ToString(), serverSettings.RecipientViewRoot.ToCanonicalName());
}
if (serverSettings.ConfigurationDomainControllers != null)
{
stringBuilder.AppendFormat(format, RpsCmdletMetadata.ADConfigurationDomainControllers, string.Join <Fqdn>(",", serverSettings.ConfigurationDomainControllers.Values));
}
if (serverSettings.PreferredGlobalCatalogs != null)
{
stringBuilder.AppendFormat(format, RpsCmdletMetadata.ADPreferredGlobalCatalogs.ToString(), string.Join <Fqdn>(",", serverSettings.PreferredGlobalCatalogs.Values));
}
if (serverSettings.PreferredDomainControllers != null)
{
stringBuilder.AppendFormat(format, RpsCmdletMetadata.ADPreferredDomainControllers.ToString(), string.Join <Fqdn>(",", serverSettings.PreferredDomainControllers.ToArray()));
}
RunspaceServerSettings runspaceServerSettings = serverSettings as RunspaceServerSettings;
if (runspaceServerSettings == null)
{
CmdletLogger.SafeAppendGenericInfo(cmdletUniqueId, key, stringBuilder.ToString());
CmdletLogger.SafeAppendGenericInfo(cmdletUniqueId, "RunspaceServerSettings", "null");
return;
}
if (runspaceServerSettings.UserConfigurationDomainController != null)
{
stringBuilder.AppendFormat(format, RpsCmdletMetadata.ADUserConfigurationDomainController.ToString(), runspaceServerSettings.UserConfigurationDomainController);
}
if (runspaceServerSettings.UserPreferredGlobalCatalog != null)
{
stringBuilder.AppendFormat(format, RpsCmdletMetadata.ADUserPreferredGlobalCatalog.ToString(), runspaceServerSettings.UserConfigurationDomainController);
}
if (runspaceServerSettings.UserPreferredDomainControllers != null)
{
stringBuilder.AppendFormat(format, RpsCmdletMetadata.ADUserPreferredDomainControllers.ToString(), string.Join <Fqdn>(",", runspaceServerSettings.UserPreferredDomainControllers.ToArray()));
}
CmdletLogger.SafeAppendGenericInfo(cmdletUniqueId, key, stringBuilder.ToString());
}
protected override void InternalProcessRecord()
{
TaskLogger.LogEnter();
if (this.approvalRequired)
{
string text = this.SubmitApprovalRequest(this.ApprovalAction);
this.WriteApprovalRequiredWarning(text);
string text2 = string.Format("Approval Request Message ID: {0}", text);
base.AdditionalLogData = text2;
CmdletLogger.SafeAppendGenericInfo(base.CurrentTaskContext.UniqueId, "DGMemberTaskBase.Log", text2);
}
base.InternalProcessRecord();
TaskLogger.LogExit();
}
private void ExtractRbacDataFromRunspace(object sender, EventArgs e)
{
ADObjectId adobjectId = null;
OrganizationId organizationId = null;
ExchangePropertyContainer.InitializeExchangePropertyContainerIfNeeded(this.context.SessionState, out adobjectId, out organizationId);
ExchangeRunspaceConfiguration exchangeRunspaceConfiguration = null;
if (this.context.SessionState != null)
{
exchangeRunspaceConfiguration = ExchangePropertyContainer.GetExchangeRunspaceConfiguration(this.context.SessionState);
}
OrganizationId organizationId2;
string executingUserIdentityName;
SmtpAddress executingWindowsLiveId;
if (exchangeRunspaceConfiguration == null)
{
if (this.context.SessionState != null)
{
organizationId = (organizationId ?? ExchangePropertyContainer.GetExecutingUserOrganizationId(this.context.SessionState));
adobjectId = (adobjectId ?? ExchangePropertyContainer.GetExecutingUserId(this.context.SessionState));
}
organizationId2 = organizationId;
executingUserIdentityName = ((adobjectId == null) ? string.Empty : adobjectId.Name);
}
else
{
exchangeRunspaceConfiguration.TryGetExecutingUserId(out adobjectId);
executingUserIdentityName = exchangeRunspaceConfiguration.IdentityName;
exchangeRunspaceConfiguration.TryGetExecutingWindowsLiveId(out executingWindowsLiveId);
organizationId = (exchangeRunspaceConfiguration.PartnerMode ? OrganizationId.ForestWideOrgId : exchangeRunspaceConfiguration.OrganizationId);
organizationId2 = exchangeRunspaceConfiguration.OrganizationId;
SecurityIdentifier value;
exchangeRunspaceConfiguration.TryGetExecutingUserSid(out value);
CmdletLogger.SafeSetLogger(this.context.UniqueId, RpsCmdletMetadata.ExecutingUserSid, value);
}
if (this.context.InvocationInfo != null && this.context.InvocationInfo.IsVerboseOn && !TaskLogger.IsSetupLogging)
{
string executingUserId = (adobjectId != null) ? adobjectId.ToCanonicalName() : string.Empty;
string executingUserOrganizationId = (organizationId != null) ? organizationId.ToString() : string.Empty;
string currentOrganizationId = (organizationId2 != null) ? organizationId2.ToString() : string.Empty;
if (this.context.CommandShell != null)
{
this.context.CommandShell.WriteVerbose(Strings.VerboseExecutingUserContext(executingUserId, executingUserOrganizationId, currentOrganizationId, (exchangeRunspaceConfiguration == null) ? Strings.DisabledString : Strings.EnabledString));
}
}
this.context.ExchangeRunspaceConfig = exchangeRunspaceConfiguration;
this.context.UserInfo = new TaskUserInfo(organizationId, organizationId2, adobjectId, executingUserIdentityName, executingWindowsLiveId);
}
private void StartBudgetProcess(object sender, EventArgs e)
{
string cmdLetName = null;
if (this.context.InvocationInfo != null)
{
cmdLetName = this.context.InvocationInfo.CommandName;
}
this.DisposeCostHandle();
this.SafeBudgetAction(delegate(BudgetInformation budgetInfo)
{
CmdletLogger.SafeSetLogger(this.context.UniqueId, RpsCmdletMetadata.UserBudgetOnStart, budgetInfo.Budget.GetCmdletBudgetUsage());
});
this.SafeBudgetAction(delegate(BudgetInformation budgetInfo)
{
budgetInfo.Budget.EndLocal();
});
this.SafeBudgetAction(delegate(BudgetInformation budgetInfo)
{
budgetInfo.Handle = budgetInfo.Budget.StartCmdlet(cmdLetName);
});
if (!this.casCostHandleDisabled)
{
this.SafeBudgetAction(delegate(BudgetInformation budgetInfo)
{
try
{
budgetInfo.Budget.StartLocal(string.Format("Task.StartBudgetProcess.{0}", cmdLetName), default(TimeSpan));
budgetInfo.Budget.LocalCostHandle.MaxLiveTime = TimeSpan.FromHours(1.0);
}
catch (InvalidOperationException)
{
try
{
CmdletLogger.SafeAppendGenericError("StartLocalBudgetFailed", cmdLetName, false);
budgetInfo.Budget.EndLocal();
}
catch (Exception)
{
}
}
});
return;
}
ThrottlingModule <T> .LogInformationTrace("CasCostHandle is not enabled in cmdlet '{0}'", new object[]
{
cmdLetName
});
}
protected IDisposable CreatePiiSuppressionContext(IConfigurable outputObject)
{
ConfigurableObject configurableObject = outputObject as ConfigurableObject;
if (configurableObject == null)
{
return(null);
}
if (configurableObject.SkipPiiRedaction || SuppressingPiiProperty.IsExcludedSchemaType(configurableObject.ObjectSchema.GetType()) || (VariantConfiguration.InvariantNoFlightingSnapshot.CmdletInfra.SkipPiiRedactionForForestWideObject.Enabled && TaskHelper.IsForestWideADObject(outputObject as ADObject)))
{
return(null);
}
CmdletLogger.SafeSetLogger(this.CurrentTaskContext.UniqueId, RpsCmdletMetadata.IsOutputObjectRedacted, true);
return(SuppressingPiiContext.Create(true, this.CurrentPiiMap));
}
// Token: 0x06001674 RID: 5748 RVA: 0x00054FE0 File Offset: 0x000531E0
private void TryFailOver()
{
ADDriverContext threadADContext = ADSessionSettings.GetThreadADContext();
ADServerSettings adserverSettings = (threadADContext != null) ? threadADContext.ServerSettings : null;
if (adserverSettings != null && adserverSettings.IsFailoverRequired())
{
ADServerSettings newServerSettings;
string str;
if (adserverSettings.TryFailover(out newServerSettings, out str, false))
{
this.PersistNewServerSettings(newServerSettings);
return;
}
CmdletLogger.SafeAppendGenericInfo(this.context.UniqueId, "ADServerSettings-TryFailOver", "Failed - " + str);
}
}
internal static IEnumerable <PSObject> RPSProxyExecution(Guid cmdletUniqueId, PSCommand command, string serverFqn, ExchangeRunspaceConfiguration runspaceConfig, int serverVersion, bool asyncProxying, Task.TaskWarningLoggingDelegate writeWarning)
{
Uri uri = ProxyHelper.BuildCmdletProxyUri(serverFqn, runspaceConfig, serverVersion);
IEnumerable <PSObject> result;
try
{
RemoteConnectionInfo connectionInfo = ProxyHelper.BuildProxyWSManConnectionInfo(uri);
ProxyPSCommand proxyPSCommand = new ProxyPSCommand(connectionInfo, command, asyncProxying, writeWarning);
result = proxyPSCommand.Invoke();
}
catch (Exception)
{
CmdletLogger.SafeAppendGenericInfo(cmdletUniqueId, "TargetUri", uri.ToString());
throw;
}
return(result);
}
internal static void LogADServerSettings(Guid cmdletUniqueId, ADServerSettings serverSettings)
{
if (serverSettings == null)
{
CmdletLogger.SafeAppendGenericInfo(cmdletUniqueId, "ADServerSettings", "null");
return;
}
CmdletLogger.SafeSetLogger(cmdletUniqueId, RpsCmdletMetadata.ADViewEntireForest, serverSettings.ViewEntireForest);
if (serverSettings.RecipientViewRoot != null)
{
CmdletLogger.SafeSetLogger(cmdletUniqueId, RpsCmdletMetadata.ADRecipientViewRoot, serverSettings.RecipientViewRoot.ToCanonicalName());
}
if (serverSettings.ConfigurationDomainControllers != null)
{
CmdletLogger.SafeSetLogger(cmdletUniqueId, RpsCmdletMetadata.ADConfigurationDomainControllers, string.Join <Fqdn>(",", serverSettings.ConfigurationDomainControllers.Values));
}
if (serverSettings.PreferredGlobalCatalogs != null)
{
CmdletLogger.SafeSetLogger(cmdletUniqueId, RpsCmdletMetadata.ADPreferredGlobalCatalogs, string.Join <Fqdn>(",", serverSettings.PreferredGlobalCatalogs.Values));
}
if (serverSettings.PreferredDomainControllers != null)
{
CmdletLogger.SafeSetLogger(cmdletUniqueId, RpsCmdletMetadata.ADPreferredDomainControllers, string.Join <Fqdn>(",", serverSettings.PreferredDomainControllers.ToArray()));
}
RunspaceServerSettings runspaceServerSettings = serverSettings as RunspaceServerSettings;
if (runspaceServerSettings == null)
{
CmdletLogger.SafeAppendGenericInfo(cmdletUniqueId, "RunspaceServerSettings", "null");
return;
}
if (runspaceServerSettings.UserConfigurationDomainController != null)
{
CmdletLogger.SafeSetLogger(cmdletUniqueId, RpsCmdletMetadata.ADUserConfigurationDomainController, runspaceServerSettings.UserConfigurationDomainController);
}
if (runspaceServerSettings.UserPreferredGlobalCatalog != null)
{
CmdletLogger.SafeSetLogger(cmdletUniqueId, RpsCmdletMetadata.ADUserPreferredGlobalCatalog, runspaceServerSettings.UserConfigurationDomainController);
}
if (runspaceServerSettings.UserPreferredDomainControllers != null)
{
CmdletLogger.SafeSetLogger(cmdletUniqueId, RpsCmdletMetadata.ADUserPreferredDomainControllers, string.Join <Fqdn>(",", runspaceServerSettings.UserPreferredDomainControllers.ToArray()));
}
}
internal static IEnumerable <PSObject> Invoke(Guid cmdletUniqueId, string pswsServiceUri, string cmdletCommand, NetworkCredential credential, NameValueCollection headersTobeAdd, TypeTable typeTable)
{
CommandInvocation.CheckArgumentNull("pswsServiceUri", pswsServiceUri);
CommandInvocation.CheckArgumentNull("cmdletCommand", cmdletCommand);
CommandInvocation.CheckArgumentNull("credential", credential);
int tickCount = Environment.TickCount;
string value;
string value2;
ResponseContent responseContent = CommandInvocation.CreateRequest(pswsServiceUri, cmdletCommand, credential, headersTobeAdd, out value, out value2);
while (responseContent.Status == ExecutionStatus.Executing)
{
int num = Environment.TickCount - tickCount;
if (num > 600000)
{
throw new PswsProxyException(Strings.PswsInvocationTimout(600000));
}
Thread.Sleep(1000);
responseContent = CommandInvocation.ResumeRequest(pswsServiceUri, responseContent.Id, credential, headersTobeAdd, out value2);
}
CmdletLogger.SafeAppendGenericInfo(cmdletUniqueId, "TicksElapsed", (Environment.TickCount - tickCount).ToString());
if (responseContent.Status == ExecutionStatus.Error)
{
CmdletLogger.SafeAppendGenericInfo(cmdletUniqueId, "RequestXml", value);
CmdletLogger.SafeAppendGenericInfo(cmdletUniqueId, "ResponseXml", value2);
StringBuilder stringBuilder = new StringBuilder();
if (headersTobeAdd != null)
{
foreach (string text in headersTobeAdd.AllKeys)
{
stringBuilder.Append(text);
stringBuilder.Append(':');
stringBuilder.Append(headersTobeAdd[text]);
stringBuilder.Append(' ');
}
}
CmdletLogger.SafeAppendGenericInfo(cmdletUniqueId, "RequestHeaders", stringBuilder.ToString());
throw new PswsProxyCmdletException(responseContent.Error.Exception);
}
return(ObjectTransfer.GetResultObjects(responseContent.OutputXml, typeTable));
}
// Token: 0x06001613 RID: 5651 RVA: 0x00052AE4 File Offset: 0x00050CE4
private static bool ShouldProxyCmdlet(TaskContext context, string remoteServerFqdn, int remoteServerVersion)
{
if (string.IsNullOrWhiteSpace(remoteServerFqdn))
{
return(false);
}
if (context.ExchangeRunspaceConfig == null)
{
return(false);
}
if (ExTraceGlobals.FaultInjectionTracer.IsTraceEnabled(TraceType.FaultInjection))
{
bool flag = false;
ProxyHelper.FaultInjection_ShouldForcedlyProxyCmdlet(context.ExchangeRunspaceConfig.ConfigurationSettings.OriginalConnectionUri, remoteServerFqdn, ref flag);
if (flag)
{
return(true);
}
}
string localServerFqdn = TaskHelper.GetLocalServerFqdn(null);
if (string.IsNullOrEmpty(localServerFqdn))
{
CmdletLogger.SafeAppendGenericError(context.UniqueId, "ShouldProxyCmdlet", "GetLocalServerFqdn returns null/empty value", false);
return(false);
}
if (string.Equals(remoteServerFqdn, localServerFqdn, StringComparison.OrdinalIgnoreCase))
{
return(false);
}
if (CmdletProxy.CanServerBeProxiedTo(remoteServerVersion))
{
return(true);
}
CmdletLogger.SafeAppendGenericInfo(context.UniqueId, "ShouldProxyCmdlet", string.Format("Remote server version {0} doesn't support be proxied.", ProxyHelper.GetFriendlyVersionInformation(remoteServerVersion)));
return(false);
}
// Token: 0x06001606 RID: 5638 RVA: 0x000522DC File Offset: 0x000504DC
private void OnError(object sender, GenericEventArg <TaskErrorEventArg> genericEventArg)
{
if (genericEventArg.Data.ExceptionHandled)
{
return;
}
Exception exception = genericEventArg.Data.Exception;
Guid uniqueId = this.context.UniqueId;
Exception ex = CmdletStaticDataWithUniqueId <Exception> .Get(uniqueId);
if (ex != null && ex != exception)
{
CmdletLogger.SafeAppendGenericError(uniqueId, this.context.Stage.ToString() + ".FromWriteError", ex.ToString(), false);
}
bool isUnhandledException = (genericEventArg.Data.IsUnknownException != null) ? genericEventArg.Data.IsUnknownException.Value : TaskHelper.IsTaskUnhandledException(exception);
CmdletLogger.SafeAppendGenericError(uniqueId, this.context.Stage.ToString(), exception.ToString(), isUnhandledException);
if (exception is LocalizedException)
{
CmdletLogger.SafeAppendGenericError(uniqueId, "ExceptionStringId", ((LocalizedException)exception).LocalizedString.StringId, false);
if (CmdletLogHelper.NeedConvertLogMessageToUS)
{
LocalizedException ex2 = (LocalizedException)exception;
IFormatProvider formatProvider = ex2.FormatProvider;
try
{
ex2.FormatProvider = CmdletLogHelper.DefaultLoggingCulture;
CmdletLogger.SafeAppendGenericError(uniqueId, this.context.Stage.ToString() + "(en-us)", ex2.ToString(), false);
}
finally
{
ex2.FormatProvider = formatProvider;
}
}
}
}
// Token: 0x06001644 RID: 5700 RVA: 0x00053BE8 File Offset: 0x00051DE8
private void ProxyCmdletExecution(CmdletProxyInfo cmdletProxyInfo)
{
ExAssert.RetailAssert(this.context.ExchangeRunspaceConfig != null, "this.context.ExchangeRunspaceConfig should not be null.");
string remoteServerFqdn = cmdletProxyInfo.RemoteServerFqdn;
int remoteServerVersion = cmdletProxyInfo.RemoteServerVersion;
string friendlyVersionInformation = ProxyHelper.GetFriendlyVersionInformation(remoteServerVersion);
CmdletProxyInfo.ChangeCmdletProxyParametersDelegate changeCmdletProxyParameters = cmdletProxyInfo.ChangeCmdletProxyParameters;
if (Microsoft.Exchange.Diagnostics.Components.Tasks.ExTraceGlobals.FaultInjectionTracer.IsTraceEnabled(TraceType.FaultInjection))
{
Microsoft.Exchange.Diagnostics.Components.Tasks.ExTraceGlobals.FaultInjectionTracer.TraceTest <string>(3720752445U, ref remoteServerFqdn);
UserToken userToken = this.context.ExchangeRunspaceConfig.ConfigurationSettings.UserToken;
ProxyHelper.FaultInjection_UserSid(ref userToken);
Microsoft.Exchange.Diagnostics.Components.Tasks.ExTraceGlobals.FaultInjectionTracer.TraceTest <int>(3452316989U, ref remoteServerVersion);
}
string text = this.GeneratePswsProxyCmdlet(changeCmdletProxyParameters);
ExchangeRunspaceConfigurationSettings.ProxyMethod proxyMethod = this.DetermineProxyMethod(remoteServerVersion);
if (this.context.CommandShell != null)
{
this.context.CommandShell.WriteVerbose(Strings.VerboseCmdletProxiedToAnotherServer(text, remoteServerFqdn, friendlyVersionInformation, proxyMethod.ToString()));
}
Guid uniqueId = this.context.UniqueId;
CmdletLogger.SafeAppendColumn(uniqueId, RpsCmdletMetadata.CmdletProxyRemoteServer, this.proxiedObjectCount.ToString(), remoteServerFqdn);
CmdletLogger.SafeAppendColumn(uniqueId, RpsCmdletMetadata.CmdletProxyRemoteServerVersion, this.proxiedObjectCount.ToString(), friendlyVersionInformation.ToString());
CmdletLogger.SafeAppendColumn(uniqueId, RpsCmdletMetadata.CmdletProxyMethod, this.proxiedObjectCount.ToString(), proxyMethod.ToString());
try
{
IEnumerable <PSObject> enumerable;
if (proxyMethod == ExchangeRunspaceConfigurationSettings.ProxyMethod.RPS)
{
PSCommand command = this.GenerateProxyCmdlet(changeCmdletProxyParameters);
Task.TaskWarningLoggingDelegate writeWarning = null;
if (this.context.CommandShell != null)
{
writeWarning = new Task.TaskWarningLoggingDelegate(this.context.CommandShell.WriteWarning);
}
enumerable = ProxyHelper.RPSProxyExecution(this.context.UniqueId, command, remoteServerFqdn, this.context.ExchangeRunspaceConfig, remoteServerVersion, cmdletProxyInfo.ShouldAsyncProxy, writeWarning);
}
else
{
enumerable = CommandInvocation.Invoke(this.context.UniqueId, ProxyHelper.GetPSWSProxySiteUri(remoteServerFqdn), text, CredentialCache.DefaultNetworkCredentials, ProxyHelper.GetPSWSProxyRequestHeaders(this.context.ExchangeRunspaceConfig), this.context.ExchangeRunspaceConfig.TypeTable);
}
foreach (PSObject psobject in enumerable)
{
object sendToPipeline = psobject;
if (psobject.BaseObject != null && !(psobject.BaseObject is PSCustomObject))
{
sendToPipeline = psobject.BaseObject;
}
else if (this.context.ExchangeRunspaceConfig != null)
{
if (this.context.ExchangeRunspaceConfig.ConfigurationSettings.ClientApplication != ExchangeRunspaceConfigurationSettings.ExchangeApplication.ECP)
{
if (this.context.ExchangeRunspaceConfig.ConfigurationSettings.ClientApplication != ExchangeRunspaceConfigurationSettings.ExchangeApplication.OSP)
{
goto IL_2CB;
}
}
try
{
Task.TaskVerboseLoggingDelegate writeVerbose = null;
if (this.context.CommandShell != null)
{
writeVerbose = new Task.TaskVerboseLoggingDelegate(this.context.CommandShell.WriteWarning);
}
sendToPipeline = ProxyHelper.ConvertPSObjectToOriginalType(psobject, remoteServerVersion, writeVerbose);
}
catch (Exception ex)
{
CmdletLogger.SafeAppendGenericError(uniqueId, "ConvertPSObjectToOriginalTyp", ex, new Func <Exception, bool>(TaskHelper.IsTaskUnhandledException));
Diagnostics.ReportException(ex, Constants.CoreEventLogger, TaskEventLogConstants.Tuple_UnhandledException, null, null, Microsoft.Exchange.Diagnostics.Components.Configuration.Core.ExTraceGlobals.InstrumentationTracer, "Exception from ProxyHelper.ConvertPSObjectToOriginalType : {0}");
}
}
IL_2CB:
if (this.context.CommandShell != null)
{
this.context.CommandShell.WriteObject(sendToPipeline);
}
}
}
catch (Exception ex2)
{
CmdletLogger.SafeAppendGenericError(this.context.UniqueId, "ProxyCmdletExecution", ex2, new Func <Exception, bool>(TaskHelper.IsTaskUnhandledException));
if (this.context.CommandShell != null)
{
this.context.CommandShell.WriteError(new CmdletProxyException(text, remoteServerFqdn, friendlyVersionInformation, proxyMethod.ToString(), ex2.Message), ExchangeErrorCategory.ServerOperation, null);
}
}
}
protected override void ProcessRecord()
{
base.ProcessRecord();
var logger = new CmdletLogger(TreatWarningsAsErrors);
try
{
logger.LogInfo("About to start importing data from Dynamics365");
var manager = new Dynamics365DataManager();
var cancellationTokenSource = new CancellationTokenSource();
var importConfig = new CrmImportConfig();
if (!string.IsNullOrWhiteSpace(ConfigFilePath))
{
if (!File.Exists(ConfigFilePath))
{
WriteWarning($"Import config file path does not exist, will be ignored {ConfigFilePath}");
}
else
{
importConfig = CrmImportConfig.GetConfiguration(ConfigFilePath);
}
}
PopulateConfigFile(importConfig);
if (!Directory.Exists(JsonFolderPath))
{
WriteWarning($"JsonFolderPath {JsonFolderPath} does not exist, cannot continue!");
throw new DirectoryNotFoundException($"JsonFolderPath {JsonFolderPath} does not exist, cannot continue!");
}
CrmSchemaConfiguration schemaConfig = null;
if (CsvImport)
{
if (string.IsNullOrWhiteSpace(SchemaFilePath))
{
throw new ConfigurationException("Schema file is required for CSV Import!");
}
schemaConfig = CrmSchemaConfiguration.ReadFromFile(SchemaFilePath);
logger.LogInfo("Using Csv import");
}
else
{
logger.LogInfo("Using JSon import");
}
if (MaxThreads > 1)
{
var result = manager.StartImport(importConfig, logger, cancellationTokenSource, ConnectionString, MaxThreads, CsvImport, schemaConfig)
.ContinueWith(a =>
{
logger.LogInfo("Dynamics365 data import completed successfully.");
},
cancellationTokenSource.Token);
result.Wait(cancellationTokenSource.Token);
}
else
{
manager.StartSingleThreadedImport(importConfig, new CmdletLoggerPS(this, TreatWarningsAsErrors), cancellationTokenSource, ConnectionString, CsvImport, schemaConfig);
}
}
catch (Exception exception)
{
var errorMessage = $"Dynamics365 data import failed: {exception.Message}";
logger.LogVerbose(errorMessage);
logger.LogError(errorMessage);
throw;
}
}
private void InitializeRunspaceServerSettings(object sender, EventArgs e)
{
ISessionState sessionState = this.CurrentTaskContext.SessionState;
ADServerSettings adserverSettings = null;
bool flag = false;
bool flag2 = false;
string value = null;
if (sessionState != null)
{
flag2 = ExchangePropertyContainer.IsContainerInitialized(sessionState);
if (flag2)
{
adserverSettings = ExchangePropertyContainer.GetServerSettings(sessionState);
if (adserverSettings != null)
{
value = "SessionState";
}
}
}
if (adserverSettings == null)
{
adserverSettings = ADSessionSettings.GetProcessServerSettings();
if (adserverSettings != null)
{
value = "ProcessServerSettings";
}
}
if (adserverSettings == null)
{
if (this.CurrentTaskContext.CommandShell != null)
{
this.CurrentTaskContext.CommandShell.TryGetVariableValue <ADServerSettings>(ExchangePropertyContainer.ADServerSettingsVarName, out adserverSettings);
}
flag = (adserverSettings != null);
if (adserverSettings != null)
{
value = "CommandShell";
}
}
if (TopologyProvider.CurrentTopologyMode == TopologyMode.ADTopologyService)
{
ADServerSettings cmdletADServerSettings = this.GetCmdletADServerSettings();
if (cmdletADServerSettings != null)
{
this.CurrentTaskContext.Items["CmdletServerSettings"] = cmdletADServerSettings;
value = "ADTopologyService";
adserverSettings = cmdletADServerSettings;
}
}
if (adserverSettings == null)
{
flag = true;
if (TopologyProvider.CurrentTopologyMode == TopologyMode.Adam)
{
if (this.CurrentTaskContext.InvocationInfo != null && this.CurrentTaskContext.InvocationInfo.IsVerboseOn)
{
this.CurrentTaskContext.CommandShell.WriteVerbose(Strings.VerboseInitializeRunspaceServerSettingsAdam);
}
if (Globals.InstanceType == InstanceType.NotInitialized)
{
Globals.InitializeSinglePerfCounterInstance();
}
value = "Adam-SimpleServerSettings";
adserverSettings = new SimpleServerSettings();
}
else if (TopologyProvider.CurrentTopologyMode == TopologyMode.Ldap)
{
if (this.CurrentTaskContext.InvocationInfo != null && this.CurrentTaskContext.CommandShell != null && this.CurrentTaskContext.InvocationInfo.IsVerboseOn)
{
this.CurrentTaskContext.CommandShell.WriteVerbose(Strings.VerboseInitializeRunspaceServerSettingsLocal);
}
Globals.InitializeMultiPerfCounterInstance("EMS");
value = "Ldap-LocalCmdLineServerSettings";
adserverSettings = LocalCmdLineServerSettings.CreateLocalCmdLineServerSettings();
}
else
{
if (this.CurrentTaskContext.InvocationInfo != null && this.CurrentTaskContext.InvocationInfo.IsVerboseOn)
{
this.CurrentTaskContext.CommandShell.WriteVerbose(Strings.VerboseInitializeRunspaceServerSettingsRemote);
}
adserverSettings = this.CreateADServerSettingsForOrganization(false);
if (adserverSettings == null)
{
value = "GCRandomly";
adserverSettings = RunspaceServerSettings.CreateRunspaceServerSettings(false);
}
}
}
if (flag)
{
if (flag2)
{
ExchangePropertyContainer.SetServerSettings(sessionState, adserverSettings);
}
else
{
sessionState.Variables[ExchangePropertyContainer.ADServerSettingsVarName] = adserverSettings;
}
}
ADSessionSettings.SetThreadADContext(new ADDriverContext(adserverSettings, ContextMode.Cmdlet));
LocalizedString localizedString = LocalizedString.Empty;
if (this.CurrentTaskContext.InvocationInfo != null)
{
localizedString = TaskVerboseStringHelper.GetADServerSettings(this.CurrentTaskContext.InvocationInfo.CommandName, adserverSettings);
if (this.CurrentTaskContext.InvocationInfo.IsVerboseOn && !string.Equals(this.CurrentTaskContext.InvocationInfo.CommandName, "Write-ExchangeSetupLog", StringComparison.OrdinalIgnoreCase) && this.CurrentTaskContext.CommandShell != null)
{
this.CurrentTaskContext.CommandShell.WriteVerbose(localizedString);
}
}
CmdletLogger.SafeSetLogger(this.CurrentTaskContext.UniqueId, RpsCmdletMetadata.RunspaceSettingsCreationHint, value);
CmdletLogHelper.LogADServerSettings(this.CurrentTaskContext.UniqueId, adserverSettings);
if (ExTraceGlobals.LogTracer.IsTraceEnabled(TraceType.InfoTrace))
{
ExTraceGlobals.LogTracer.Information <LocalizedString>(0L, "Cmdlet ADServerSettings {0}", localizedString);
}
}
private static PowerShellResults <O> InvokeCore <O>(PSCommand psCommand, RunspaceMediator runspaceMediator, IEnumerable pipelineInput, WebServiceParameters parameters, CmdletActivity activity, bool isGetListAsync)
{
Func <WarningRecord, string> func = null;
Func <Command, string> func2 = null;
PSCommandExtension.EnsureNoWriteTaskInGetRequest(psCommand, parameters);
PowerShellResults <O> powerShellResults = new PowerShellResults <O>();
ExTraceGlobals.EventLogTracer.TraceInformation <string, EcpTraceFormatter <PSCommand> >(0, 0L, "{0} tries to invoke {1}. For more details, refer to task trace", RbacPrincipal.Current.NameForEventLog, psCommand.GetTraceFormatter());
using (RunspaceProxy runspaceProxy = new RunspaceProxy(runspaceMediator))
{
runspaceProxy.SetVariable("ConfirmPreference", "None");
if (parameters != null)
{
psCommand.AddParameters(parameters);
}
using (PowerShell powerShell = runspaceProxy.CreatePowerShell(psCommand))
{
List <PSObject> list = null;
if (activity != null)
{
AsyncServiceManager.RegisterPowerShellToActivity(powerShell, activity, pipelineInput, out list, isGetListAsync);
}
else
{
AsyncServiceManager.RegisterPowerShell(powerShell);
}
int requestLatency = 0;
DateTime utcNow = DateTime.UtcNow;
try
{
TaskPerformanceRecord taskPerformanceRecord = new TaskPerformanceRecord(psCommand.GetCmdletName(), PSCommandExtension.powerShellLatencyDetectionContextFactory, EcpEventLogConstants.Tuple_EcpPowerShellInvoked, EcpEventLogConstants.Tuple_EcpPowerShellCompleted, EcpEventLogExtensions.EventLog, new IPerformanceDataProvider[]
{
PerformanceContext.Current,
RpcDataProvider.Instance,
TaskPerformanceData.CmdletInvoked,
TaskPerformanceData.BeginProcessingInvoked,
TaskPerformanceData.ProcessRecordInvoked,
TaskPerformanceData.EndProcessingInvoked,
EcpPerformanceData.PowerShellInvoke
});
try
{
using (EcpPerformanceData.PowerShellInvoke.StartRequestTimer())
{
if (list == null)
{
powerShellResults.Output = powerShell.Invoke <O>(pipelineInput).ToArray <O>();
}
else
{
powerShell.Invoke <PSObject>(pipelineInput, list);
powerShellResults.Output = Array <O> .Empty;
}
}
}
finally
{
requestLatency = (int)taskPerformanceRecord.Stop().TotalMilliseconds;
IDisposable disposable2 = taskPerformanceRecord;
if (disposable2 != null)
{
disposable2.Dispose();
}
}
List <ErrorRecord> list2 = new List <ErrorRecord>();
bool flag = false;
foreach (ErrorRecord errorRecord in powerShell.Streams.Error)
{
if (!flag)
{
flag = PSCommandExtension.TryPatchShouldContinueException(errorRecord, psCommand, parameters);
}
list2.Add(new ErrorRecord(errorRecord));
}
powerShellResults.ErrorRecords = list2.ToArray();
PowerShellResults powerShellResults2 = powerShellResults;
IEnumerable <WarningRecord> warning = powerShell.Streams.Warning;
if (func == null)
{
func = ((WarningRecord warningRecord) => warningRecord.Message);
}
powerShellResults2.Warnings = warning.Select(func).ToArray <string>();
}
catch (RuntimeException ex)
{
PSCommandExtension.TryPatchShouldContinueException(ex.ErrorRecord, psCommand, parameters);
ErrorRecord errorRecord2;
if (ex.ErrorRecord != null && !(ex is ParameterBindingException))
{
errorRecord2 = new ErrorRecord(ex.ErrorRecord);
}
else
{
errorRecord2 = new ErrorRecord(ex);
}
powerShellResults.ErrorRecords = new ErrorRecord[]
{
errorRecord2
};
}
finally
{
string text = HttpContext.Current.Request.QueryString["reqId"];
ServerLogEvent logEvent = new ServerLogEvent(psCommand, pipelineInput, requestLatency, string.IsNullOrEmpty(text) ? string.Empty : text, (powerShellResults.ErrorRecords != null && powerShellResults.ErrorRecords.Length > 0) ? powerShellResults.ErrorRecords.ToLogString() : string.Empty, (powerShellResults.Output != null) ? powerShellResults.Output.Length : 0);
ServerLogger.Instance.LogEvent(logEvent);
}
PowerShellResults powerShellResults3 = powerShellResults;
IEnumerable <Command> commands = psCommand.Commands;
if (func2 == null)
{
func2 = ((Command cmd) => cmd.CommandText);
}
powerShellResults3.Cmdlets = commands.Select(func2).ToArray <string>();
if (powerShellResults.ErrorRecords.Length > 0)
{
ExTraceGlobals.EventLogTracer.TraceError <string, EcpTraceFormatter <PSCommand>, EcpTraceFormatter <ErrorRecord[]> >(0, 0L, "{0} invoked {1} and encountered errors: {2}", RbacPrincipal.Current.NameForEventLog, psCommand.GetTraceFormatter(), powerShellResults.ErrorRecords.GetTraceFormatter());
}
CmdExecuteInfo cmdExecuteInfo = CmdletLogger.CaculateLogAndSaveToContext(powerShell, utcNow, powerShellResults.ErrorRecords);
if (cmdExecuteInfo != null)
{
powerShellResults.CmdletLogInfo = new CmdExecuteInfo[]
{
cmdExecuteInfo
};
}
}
}
return(powerShellResults);
}
