internal string GetEcpRoot(bool useWIA, string targetServerFqdn)
{
MonadConnection connection = new MonadConnection("pooled=false");
using (new OpenConnection(connection))
{
string str = Path.Combine(ConfigurationContext.Setup.BinPath, "ConnectFunctions.ps1");
using (MonadCommand monadCommand = new LoggableMonadCommand(". '" + str + "'", connection))
{
monadCommand.CommandType = CommandType.Text;
monadCommand.ExecuteNonQuery();
}
string cmdText = "Discover-EcpVirtualDirectoryForEmc";
using (MonadCommand monadCommand2 = new LoggableMonadCommand(cmdText, connection))
{
monadCommand2.CommandType = CommandType.StoredProcedure;
monadCommand2.Parameters.Add(new MonadParameter("CurrentVersion", new ServerVersion(ConfigurationContext.Setup.InstalledVersion.Major, ConfigurationContext.Setup.InstalledVersion.Minor, ConfigurationContext.Setup.InstalledVersion.Build, ConfigurationContext.Setup.InstalledVersion.Revision)));
monadCommand2.Parameters.Add(new MonadParameter("UseWIA", useWIA));
if (!string.IsNullOrEmpty(targetServerFqdn))
{
monadCommand2.Parameters.Add(new MonadParameter("TargetServerFqdn", targetServerFqdn));
}
object[] array = monadCommand2.Execute();
if (array.Length > 0)
{
return((string)array[0]);
}
}
}
return(null);
}
internal void FillWith(string commandText, MonadConnection connection)
{
using (MonadCommand monadCommand = new LoggableMonadCommand(commandText, connection))
{
this.FillWith(monadCommand);
}
}
internal void UpdateConnection(MonadConnection connection)
{
foreach (DataHandler dataHandler in this.dataHandler.DataHandlers)
{
SingleTaskDataHandler singleTaskDataHandler = (SingleTaskDataHandler)dataHandler;
singleTaskDataHandler.Command.Connection = connection;
}
}
private void SetVariable(string variableName, object value, MonadConnection connection)
{
using (MonadCommand monadCommand = new MonadCommand("Set-Variable", connection))
{
monadCommand.Parameters.AddWithValue("Name", variableName);
monadCommand.Parameters.AddWithValue("Value", value);
monadCommand.ExecuteNonQuery();
}
}
private object GetVariable(string variableName, MonadConnection connection)
{
object result;
using (MonadCommand monadCommand = new MonadCommand("Get-Variable", connection))
{
monadCommand.Parameters.AddWithValue("Name", variableName);
object[] array = monadCommand.Execute();
result = ((array.Length > 0) ? (array[0] as PSVariable).Value : null);
}
return(result);
}
public override void Open(IUIService service, WorkUnitCollection workUnits, bool enforceViewEntireForest, ResultsLoaderProfile profile)
{
this.isResultPane = !enforceViewEntireForest;
this.workUnits = workUnits;
this.commandInteractionHandler = ((service != null) ? new WinFormsCommandInteractionHandler(service) : new CommandInteractionHandler());
RunspaceServerSettingsPresentationObject runspaceServerSettingsPresentationObject = ADServerSettingsSingleton.GetInstance().CreateRunspaceServerSettingsObject();
if (enforceViewEntireForest && runspaceServerSettingsPresentationObject != null)
{
runspaceServerSettingsPresentationObject.ViewEntireForest = true;
}
this.connection = new MonadConnection(PSConnectionInfoSingleton.GetInstance().GetConnectionStringForScript(), this.commandInteractionHandler, runspaceServerSettingsPresentationObject, PSConnectionInfoSingleton.GetInstance().GetMonadConnectionInfo(profile.SerializationLevel));
this.connection.Open();
}
// Token: 0x0600139E RID: 5022 RVA: 0x0004526C File Offset: 0x0004346C
protected override ADRawEntry LoadExecutingUser(IIdentity identity, IList <PropertyDefinition> properties)
{
MonadConnection connection = new MonadConnection("timeout=30", new CommandInteractionHandler(), null, CmdletBasedRunspaceConfiguration.connectionInfo);
CmdletBasedRunspaceConfiguration.reportProgress.ReportProgress(70, 100, Strings.LoadingLogonUser(base.IdentityName), Strings.LoadingLogonUserErrorText(base.IdentityName));
ADRawEntry result;
using (new OpenConnection(connection))
{
MonadCommand monadCommand = new MonadCommand("Get-LogonUser", connection);
result = (ADRawEntry)monadCommand.Execute()[0];
}
return(result);
}
public TableDataHandler(string selectCommandText, string updateCommandText, string insertCommandText, string deleteCommandText)
{
this.DataTable = new DataTable();
this.dataAdapter = new MonadDataAdapter();
this.dataAdapter.EnforceDataSetSchema = true;
MonadConnection connection = new MonadConnection("timeout=30", new CommandInteractionHandler(), ADServerSettingsSingleton.GetInstance().CreateRunspaceServerSettingsObject(), PSConnectionInfoSingleton.GetInstance().GetMonadConnectionInfo());
this.dataAdapter.SelectCommand = new LoggableMonadCommand(selectCommandText, connection);
this.dataAdapter.UpdateCommand = new LoggableMonadCommand(updateCommandText, connection);
this.dataAdapter.UpdateCommand.UpdatedRowSource = UpdateRowSource.None;
this.dataAdapter.DeleteCommand = new LoggableMonadCommand(deleteCommandText, connection);
this.dataAdapter.InsertCommand = new LoggableMonadCommand(insertCommandText, connection);
this.dataAdapter.InsertCommand.UpdatedRowSource = UpdateRowSource.None;
this.synchronizationContext = SynchronizationContext.Current;
}
internal void EnforceADSettings()
{
ExTraceGlobals.ProgramFlowTracer.TraceFunction <ExchangeADServerSettings>(0L, "-->ExchangeSystemManagerSettings.EnforceAdSettings: {0}", this);
if (this["ADServerSettings"] == null && !EnvironmentAnalyzer.IsWorkGroup() && OrganizationType.Cloud != PSConnectionInfoSingleton.GetInstance().Type)
{
try
{
try
{
using (MonadConnection monadConnection = new MonadConnection("timeout=30", new CommandInteractionHandler(), null, PSConnectionInfoSingleton.GetInstance().GetMonadConnectionInfo()))
{
monadConnection.Open();
LoggableMonadCommand loggableMonadCommand = new LoggableMonadCommand("Get-ADServerSettingsForLogonUser", monadConnection);
object[] array = loggableMonadCommand.Execute();
if (array != null && array.Length > 0)
{
RunspaceServerSettingsPresentationObject runspaceServerSettingsPresentationObject = array[0] as RunspaceServerSettingsPresentationObject;
this.ADServerSettings = runspaceServerSettingsPresentationObject;
this.OrganizationalUnit = runspaceServerSettingsPresentationObject.RecipientViewRoot;
this.ForestViewEnabled = runspaceServerSettingsPresentationObject.ViewEntireForest;
this.GlobalCatalog = runspaceServerSettingsPresentationObject.UserPreferredGlobalCatalog;
this.ConfigurationDomainController = runspaceServerSettingsPresentationObject.UserPreferredConfigurationDomainController;
if (runspaceServerSettingsPresentationObject.UserPreferredDomainControllers != null && runspaceServerSettingsPresentationObject.UserPreferredDomainControllers.Count != 0)
{
this.DomainController = runspaceServerSettingsPresentationObject.UserPreferredDomainControllers[0];
}
}
else
{
this.SetDefaultSettings();
}
}
}
catch (Exception)
{
this.SetDefaultSettings();
}
goto IL_11A;
}
finally
{
this.waitHandle.Set();
}
}
this.waitHandle.Set();
IL_11A:
ExTraceGlobals.ProgramFlowTracer.TraceFunction <ExchangeADServerSettings>(0L, "<--ExchangeSystemManagerSettings.EnforceAdSettings: {0}", this);
}
// Token: 0x0600139F RID: 5023 RVA: 0x000452FC File Offset: 0x000434FC
protected override Result <ExchangeRoleAssignment>[] LoadRoleAssignments(IConfigurationSession session, ADRawEntry user, List <ADObjectId> existingRoleGroups)
{
MonadConnection connection = new MonadConnection("timeout=30", new CommandInteractionHandler(), null, CmdletBasedRunspaceConfiguration.connectionInfo);
object[] array;
using (new OpenConnection(connection))
{
CmdletBasedRunspaceConfiguration.reportProgress.ReportProgress(75, 100, Strings.LoadingRoleAssignment(base.IdentityName), Strings.LoadingRoleAssignmentErrorText(base.IdentityName));
MonadCommand monadCommand = new MonadCommand("Get-ManagementRoleAssignmentForLogonUser", connection);
array = monadCommand.Execute();
}
Result <ExchangeRoleAssignment>[] array2 = new Result <ExchangeRoleAssignment> [array.Length];
for (int i = 0; i < array.Length; i++)
{
array2[i] = new Result <ExchangeRoleAssignment>((ExchangeRoleAssignment)((ExchangeRoleAssignmentPresentation)array[i]).DataObject, null);
}
return(array2);
}
// Token: 0x060013A0 RID: 5024 RVA: 0x000453C8 File Offset: 0x000435C8
protected override Result <ExchangeRole>[] LoadRoles(IConfigurationSession session, List <ADObjectId> roleIds)
{
MonadConnection connection = new MonadConnection("timeout=30", new CommandInteractionHandler(), null, CmdletBasedRunspaceConfiguration.connectionInfo);
object[] roles;
using (new OpenConnection(connection))
{
CmdletBasedRunspaceConfiguration.reportProgress.ReportProgress(90, 100, Strings.LoadingRole(base.IdentityName), Strings.LoadingRoleErrorText(base.IdentityName));
MonadCommand monadCommand = new MonadCommand("Get-ManagementRoleForLogonUser", connection);
roles = monadCommand.Execute();
}
Result <ExchangeRole>[] array = new Result <ExchangeRole> [roleIds.Count];
for (int i = 0; i < roleIds.Count; i++)
{
array[i] = new Result <ExchangeRole>(this.FindRole(roles, roleIds[i]), null);
}
return(array);
}
// Token: 0x060013A1 RID: 5025 RVA: 0x00045498 File Offset: 0x00043698
protected override Result <ManagementScope>[] LoadScopes(IConfigurationSession session, ADObjectId[] scopeIds)
{
MonadConnection connection = new MonadConnection("timeout=30", new CommandInteractionHandler(), null, CmdletBasedRunspaceConfiguration.connectionInfo);
object[] scopes;
using (new OpenConnection(connection))
{
this.scopeReported = true;
CmdletBasedRunspaceConfiguration.reportProgress.ReportProgress(80, 100, Strings.LoadingScope(base.IdentityName), Strings.LoadingScopeErrorText(base.IdentityName));
MonadCommand monadCommand = new MonadCommand("Get-ManagementScopeForLogonUser", connection);
scopes = monadCommand.Execute(scopeIds);
}
Result <ManagementScope>[] array = new Result <ManagementScope> [scopeIds.Length];
for (int i = 0; i < scopeIds.Length; i++)
{
array[i] = new Result <ManagementScope>(this.FindScope(scopes, scopeIds[i]), null);
}
return(array);
}
// Token: 0x060013A2 RID: 5026 RVA: 0x00045564 File Offset: 0x00043764
protected override ManagementScope[] LoadExclusiveScopes()
{
MonadConnection connection = new MonadConnection("timeout=30", new CommandInteractionHandler(), null, CmdletBasedRunspaceConfiguration.connectionInfo);
object[] array;
using (new OpenConnection(connection))
{
if (!this.scopeReported)
{
CmdletBasedRunspaceConfiguration.reportProgress.ReportProgress(80, 100, Strings.LoadingScope(base.IdentityName), Strings.LoadingScopeErrorText(base.IdentityName));
}
MonadCommand monadCommand = new MonadCommand("Get-ExclusiveManagementScopeForLogonUser", connection);
array = monadCommand.Execute();
}
ManagementScope[] array2 = new ManagementScope[array.Length];
for (int i = 0; i < array.Length; i++)
{
array2[i] = (array[i] as ManagementScope);
}
return(array2);
}
protected override void OnExecute()
{
string commandDisplayName = this.CommandDisplayName;
WorkUnitCollectionEventArgs inputArgs = new WorkUnitCollectionEventArgs(new WorkUnitCollection());
this.OnInputRequested(inputArgs);
IUIService uiService = (IUIService)this.GetService(typeof(IUIService));
if (uiService == null)
{
throw new InvalidOperationException("TaskCommand must be sited and needs to be able to find an IUIService.");
}
Control controlToRestoreFocus = uiService.GetDialogOwnerWindow() as Control;
IRefreshable singleRefreshOnFinish = this.RefreshOnFinish;
IRefreshable[] multiRefreshOnFinish = (this.MultiRefreshOnFinish == null) ? null : ((IRefreshable[])this.MultiRefreshOnFinish.Clone());
if (this.ConfirmOperation(inputArgs))
{
WorkUnitCollection workUnits = inputArgs.WorkUnits;
if (workUnits.Count == 0)
{
WorkUnit workUnit = new WorkUnit();
workUnit.Text = commandDisplayName;
workUnit.Target = null;
workUnits.Add(workUnit);
}
IProgress progress = this.CreateProgress(new LocalizedString(commandDisplayName));
MonadCommand command = new LoggableMonadCommand();
command.CommandText = this.CommandText;
foreach (object obj in this.Parameters)
{
MonadParameter value = (MonadParameter)obj;
command.Parameters.Add(value);
}
command.ProgressReport += delegate(object sender, ProgressReportEventArgs progressReportEventArgs)
{
progress.ReportProgress(workUnits.ProgressValue, workUnits.MaxProgressValue, progressReportEventArgs.ProgressRecord.StatusDescription);
};
BackgroundWorker worker = new BackgroundWorker();
worker.DoWork += delegate(object param0, DoWorkEventArgs param1)
{
MonadConnection connection = new MonadConnection("timeout=30", new WinFormsCommandInteractionHandler(this.TestUIService ?? uiService), ADServerSettingsSingleton.GetInstance().CreateRunspaceServerSettingsObject(), PSConnectionInfoSingleton.GetInstance().GetMonadConnectionInfo());
command.Connection = connection;
using (new OpenConnection(connection))
{
command.Execute(workUnits.ToArray());
}
};
worker.RunWorkerCompleted += delegate(object sender, RunWorkerCompletedEventArgs runWorkerCompletedEventArgs)
{
command.Connection.Close();
if (runWorkerCompletedEventArgs.Error != null)
{
progress.ReportProgress(0, 0, "");
uiService.ShowError(runWorkerCompletedEventArgs.Error);
}
else
{
int num = workUnits.HasFailures ? 0 : 100;
progress.ReportProgress(num, num, "");
List <WorkUnit> list = new List <WorkUnit>(workUnits.FindByErrorOrWarning());
if (workUnits.Cancelled)
{
WorkUnit workUnit2 = list[list.Count - 1];
for (int i = 0; i < workUnit2.Errors.Count; i++)
{
if (workUnit2.Errors[i].Exception is PipelineStoppedException)
{
workUnit2.Errors.Remove(workUnit2.Errors[i]);
break;
}
}
if (workUnit2.Errors.Count == 0)
{
list.Remove(workUnit2);
}
}
if (list.Count > 0)
{
string errorMessage = null;
string warningMessage = null;
if (list.Count == 1)
{
if (this.SingleSelectionError != null)
{
errorMessage = this.SingleSelectionError(list[0].Text);
}
else
{
errorMessage = Strings.SingleSelectionError(commandDisplayName, list[0].Text);
}
if (this.SingleSelectionWarning != null)
{
warningMessage = this.SingleSelectionWarning(list[0].Text);
}
else
{
warningMessage = Strings.SingleSelectionWarning(commandDisplayName, list[0].Text);
}
}
else if (list.Count > 1)
{
if (this.MultipleSelectionError != null)
{
errorMessage = this.MultipleSelectionError(list.Count);
}
else
{
errorMessage = Strings.MultipleSelectionError(commandDisplayName, list.Count);
}
if (this.MultipleSelectionWarning != null)
{
warningMessage = this.MultipleSelectionWarning(list.Count);
}
else
{
warningMessage = Strings.MultipleSelectionWarning(commandDisplayName, list.Count);
}
}
UIService.ShowError(errorMessage, warningMessage, list, uiService);
}
}
this.PerformRefreshOnFinish(workUnits, singleRefreshOnFinish, multiRefreshOnFinish);
this.OnCompleted(inputArgs);
};
bool flag = workUnits.Count > 1;
ProgressDialog pd = null;
if (flag)
{
pd = new ProgressDialog();
pd.OkEnabled = false;
pd.Text = Strings.TaskProgressDialogTitle(commandDisplayName);
pd.UseMarquee = true;
pd.StatusText = workUnits.Description;
pd.FormClosing += delegate(object sender, FormClosingEventArgs formClosingEventArgs)
{
if (worker.IsBusy)
{
if (pd.CancelEnabled)
{
pd.CancelEnabled = false;
WinformsHelper.InvokeAsync(delegate
{
command.Cancel();
}, pd);
}
formClosingEventArgs.Cancel = worker.IsBusy;
}
};
pd.FormClosed += delegate(object param0, FormClosedEventArgs param1)
{
if (controlToRestoreFocus != null)
{
controlToRestoreFocus.Focus();
}
};
worker.RunWorkerCompleted += delegate(object sender, RunWorkerCompletedEventArgs runWorkerCompletedEventArgs)
{
pd.UseMarquee = false;
pd.Maximum = 100;
pd.Value = 100;
pd.Close();
};
command.ProgressReport += delegate(object sender, ProgressReportEventArgs progressReportEventArgs)
{
if ((progressReportEventArgs.ProgressRecord.RecordType == ProgressRecordType.Processing && progressReportEventArgs.ProgressRecord.PercentComplete > 0 && progressReportEventArgs.ProgressRecord.PercentComplete < 100) || workUnits[0].Status == WorkUnitStatus.Completed)
{
pd.UseMarquee = false;
}
pd.Maximum = workUnits.MaxProgressValue;
pd.Value = workUnits.ProgressValue;
pd.StatusText = workUnits.Description;
};
pd.ShowModeless(uiService.GetDialogOwnerWindow() as IServiceProvider);
uiService = pd.ShellUI;
}
SynchronizationContext.SetSynchronizationContext(new WindowsFormsSynchronizationContext());
worker.RunWorkerAsync();
base.OnExecute();
}
}
public LoggableMonadCommand(string cmdText, MonadConnection connection) : base(cmdText, connection)
{
this.RegisterListeners();
}
internal SingleTaskDataHandler(string saveCommandText, MonadConnection connection) : this(new LoggableMonadCommand(saveCommandText, connection))
{
}
private void Fill(RefreshRequestEventArgs e)
{
ExTraceGlobals.ProgramFlowTracer.TraceFunction <DataTableLoader>((long)this.GetHashCode(), "-->DataTableLoader.Fill: {0}", this);
ResultsLoaderProfile profile = e.Argument as ResultsLoaderProfile;
if (profile != null)
{
DataTable dataTable = e.Result as DataTable;
dataTable.RowChanged += delegate(object sender, DataRowChangeEventArgs eventArgs)
{
if (eventArgs.Action == DataRowAction.Add)
{
this.FillPrimaryKeysBasedOnLambdaExpression(eventArgs.Row, profile);
}
};
DataTable dataTable2 = dataTable.Clone();
dataTable2.RowChanged += delegate(object sender, DataRowChangeEventArgs eventArgs)
{
if (eventArgs.Action == DataRowAction.Add)
{
this.FillPrimaryKeysBasedOnLambdaExpression(eventArgs.Row, profile);
}
};
if (!this.EnforeViewEntireForest && !profile.HasPermission())
{
goto IL_26F;
}
using (DataAdapterExecutionContext dataAdapterExecutionContext = this.executionContextFactory.CreateExecutionContext())
{
dataAdapterExecutionContext.Open(base.UIService, this.WorkUnits, this.EnforeViewEntireForest, profile);
foreach (AbstractDataTableFiller filler in profile.TableFillers)
{
if (profile.IsRunnable(filler))
{
if (e.CancellationPending)
{
break;
}
profile.BuildCommand(filler);
if (profile.FillType == 1 || this.IsPreFillForResolving(filler))
{
dataAdapterExecutionContext.Execute(filler, dataTable2, profile);
this.MergeChanges(dataTable2, dataTable);
dataTable2.Clear();
}
else
{
dataAdapterExecutionContext.Execute(filler, dataTable, profile);
}
}
}
goto IL_26F;
}
}
MonadCommand monadCommand = e.Argument as MonadCommand;
if (monadCommand != null)
{
this.AttachCommandToMonitorWarnings(monadCommand);
using (MonadConnection monadConnection = new MonadConnection(PSConnectionInfoSingleton.GetInstance().GetConnectionStringForScript(), new CommandInteractionHandler(), ADServerSettingsSingleton.GetInstance().CreateRunspaceServerSettingsObject(), PSConnectionInfoSingleton.GetInstance().GetMonadConnectionInfo(ExchangeRunspaceConfigurationSettings.SerializationLevel.Full)))
{
monadConnection.Open();
monadCommand.Connection = monadConnection;
using (MonadDataAdapter monadDataAdapter = new MonadDataAdapter(monadCommand))
{
DataTable dataTable3 = (DataTable)e.Result;
if (dataTable3.Columns.Count != 0)
{
monadDataAdapter.MissingSchemaAction = MissingSchemaAction.Ignore;
monadDataAdapter.EnforceDataSetSchema = true;
}
ExTraceGlobals.ProgramFlowTracer.TraceFunction <DataTableLoader, MonadCommand>((long)this.GetHashCode(), "-->DataTableLoader.Fill: calling dataAdapter.Fill: {0}. Command:{1}", this, monadCommand);
monadDataAdapter.Fill(dataTable3);
ExTraceGlobals.ProgramFlowTracer.TraceFunction <DataTableLoader, MonadCommand>((long)this.GetHashCode(), "<--DataTableLoader.Fill: calling dataAdaptr.Fill: {0}. Command:{1}", this, monadCommand);
}
}
this.DetachCommandFromMonitorWarnings(monadCommand);
}
IL_26F:
this.OnFillTable(e);
ExTraceGlobals.ProgramFlowTracer.TraceFunction <DataTableLoader>((long)this.GetHashCode(), "<--DataTableLoader.Fill: {0}", this);
}
private static void LoadBaseUrlViaCmdlet(HelpProvider.HelpAppName appName, RunspaceServerSettingsPresentationObject runspaceServerSettings, MonadConnectionInfo monadConnectionInfo)
{
if (appName != HelpProvider.HelpAppName.Toolbox)
{
if (appName != HelpProvider.HelpAppName.Eap)
{
throw new InvalidOperationException("appName is not a valid HelpAppName enum. Check caller of Initialize how we get this value.");
}
}
try
{
ExchangeAssistance exchangeAssistance = null;
MonadConnection connection = new MonadConnection("timeout=30", new CommandInteractionHandler(), runspaceServerSettings, monadConnectionInfo);
using (new OpenConnection(connection))
{
using (MonadCommand monadCommand = new MonadCommand("Get-ExchangeAssistanceConfig", connection))
{
object[] array = monadCommand.Execute();
if (array != null && array.Length != 0)
{
exchangeAssistance = (array[0] as ExchangeAssistance);
}
}
}
if (exchangeAssistance != null)
{
if (exchangeAssistance.ManagementConsoleHelpURL != null)
{
HelpProvider.baseUrl = Utilities.NormalizeUrl(exchangeAssistance.ManagementConsoleHelpURL);
}
if (exchangeAssistance.ManagementConsoleFeedbackEnabled)
{
HelpProvider.managementConsoleFeedbackUrl = exchangeAssistance.ManagementConsoleFeedbackURL;
}
else
{
HelpProvider.managementConsoleFeedbackUrl = null;
}
if (exchangeAssistance.PrivacyLinkDisplayEnabled)
{
HelpProvider.privacyStatementUrl = exchangeAssistance.PrivacyStatementURL;
}
else
{
HelpProvider.privacyStatementUrl = null;
}
if (exchangeAssistance.WindowsLiveAccountURLEnabled)
{
HelpProvider.windowsLiveAccountUrl = exchangeAssistance.WindowsLiveAccountPageURL;
}
else
{
HelpProvider.windowsLiveAccountUrl = null;
}
if (exchangeAssistance.CommunityLinkDisplayEnabled)
{
HelpProvider.communityUrl = exchangeAssistance.CommunityURL;
}
else
{
HelpProvider.communityUrl = null;
}
}
}
catch (CommandExecutionException ex)
{
ExTraceGlobals.CoreTracer.TraceDebug <string>(0L, "CommandExecution Exception in LoadBaseURL: {0}", ex.Message);
}
catch (CmdletInvocationException ex2)
{
ExTraceGlobals.CoreTracer.TraceDebug <string>(0L, "CmdletInvocationException Exception in LoadBaseURL: {0}", ex2.Message);
}
catch (PipelineStoppedException ex3)
{
ExTraceGlobals.CoreTracer.TraceDebug <string>(0L, "PipelineStopped Exception in LoadBaseURL: {0}", ex3.Message);
}
HelpProvider.callingAppName = appName;
}
