internal void FillWith(MonadCommand command) { using (new OpenConnection(command.Connection)) { this.CopyFrom(command.Execute()); } }
public override void Apply(MrsPSHandler psHandler, MailboxSession mailboxSession) { using (MonadCommand command = psHandler.GetCommand(MrsCmdlet.SetConsumerMailbox)) { int num = 1; command.Parameters.AddWithValue("Identity", ConsumerMailboxIdParameter.Parse(mailboxSession.MailboxGuid.ToString())); if (this.LastName != null) { command.Parameters.AddWithValue("LastName", this.LastName); } if (this.FirstName != null) { command.Parameters.AddWithValue("FirstName", this.FirstName); } if (this.BirthdayInt != 0) { command.Parameters.AddWithValue("Birthdate", this.BirthdayInt); command.Parameters.AddWithValue("BirthdayPrecision", this.BirthdayPrecision); } if (command.Parameters.Count > num) { command.Execute(); } } }
public IEnumerable <T> RunOneCommand <T>(string command, Dictionary <string, object> parameters, bool ignoreNotFoundErrors) { Collection <PSObject> collection = this.RunCommand(command, parameters, ignoreNotFoundErrors); List <T> list = new List <T>(); if (collection.Count > 0) { if (collection[0] != null && collection[0].BaseObject != null && collection[0].BaseObject is PSCustomObject && MonadCommand.CanDeserialize(collection[0])) { using (IEnumerator <PSObject> enumerator = collection.GetEnumerator()) { while (enumerator.MoveNext()) { PSObject psobject = enumerator.Current; if (psobject != null) { list.Add((T)((object)MonadCommand.Deserialize(psobject))); } } return(list); } } throw new InvalidOperationException(Strings.HybridInfoPurePSObjectsNotSupported); } return(list); }
internal static object ConvertPSObjectToOriginalType(PSObject psObject, int remoteServerVersion, Task.TaskVerboseLoggingDelegate writeVerbose) { if (psObject == null) { throw new ArgumentNullException("psObject"); } Type type = MonadCommand.ResolveType(psObject); if (remoteServerVersion >= Server.E15MinVersion) { if (psObject.Members["SerializationData"] == null || psObject.Members["SerializationData"].Value == null) { if (writeVerbose != null) { writeVerbose(Strings.VerboseSerializationDataNotExist); } } else { try { return(ProxyHelper.TypeConvertor.ConvertFrom(psObject, type, null, true)); } catch (Exception ex) { if (writeVerbose != null) { writeVerbose(Strings.VerboseFailedToDeserializePSObject(ex.Message)); } } } } return(MockObjectInformation.TranslateToMockObject(type, psObject)); }
private static IList <string> BuildParameterStrings(DataRow row, IList <ParameterProfile> paramInfos) { List <string> list = new List <string>(); foreach (ParameterProfile parameterProfile in paramInfos) { if (parameterProfile.IsRunnable(row)) { switch (parameterProfile.ParameterType) { case ParameterType.Switched: list.Add(string.Format("-{0} ", parameterProfile.Name)); break; case ParameterType.Column: case ParameterType.ModifiedColumn: { string arg = MonadCommand.FormatParameterValue(MonadSaveTask.ConvertToParameterValue(row, parameterProfile)); list.Add(string.Format("-{0} {1} ", parameterProfile.Name, arg)); break; } default: list.Add(string.Empty); break; } } else { list.Add(string.Empty); } } return(list); }
public static void StartExecution(object sender, StartExecutionEventArgs e) { MonadCommand monadCommand = sender as MonadCommand; StringBuilder stringBuilder = new StringBuilder(); if (e.Pipeline != null) { int num = 0; foreach (object value in e.Pipeline) { if (num != 0) { stringBuilder.Append(","); } num++; stringBuilder.Append(MonadCommand.FormatParameterValue(value)); } if (stringBuilder.Length > 0) { stringBuilder.Append(" | "); } } stringBuilder.Append(monadCommand.ToString()); CommandLoggingDialog.LogStart(e.Guid, (DateTime)ExDateTime.Now, stringBuilder.ToString()); }
public object[] ExecuteCommand(string command) { if (command == string.Empty) { throw new ArgumentNullException("command"); } object[] result = null; lock (this.monadConnection) { try { this.monadConnection.Open(); using (MonadCommand monadCommand = new MonadCommand(command, this.monadConnection)) { monadCommand.CommandType = CommandType.Text; result = monadCommand.Execute(); } } finally { if (this.monadConnection.State == ConnectionState.Open) { this.monadConnection.Close(); } } } return(result); }
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(); } }
public override void Execute(AbstractDataTableFiller filler, DataTable table, ResultsLoaderProfile profile) { MonadAdapterFiller monadAdapterFiller = filler as MonadAdapterFiller; if (monadAdapterFiller != null && !monadAdapterFiller.HasPermission() && (this.isResultPane || monadAdapterFiller.IsResolving)) { return; } Stopwatch stopwatch = new Stopwatch(); this.BeginExecute(filler, profile); MonadCommand monadCommand = null; if (monadAdapterFiller != null) { monadCommand = monadAdapterFiller.Command; } else if (filler is SupervisionListFiller) { monadCommand = ((SupervisionListFiller)filler).Command; } if (monadCommand != null) { monadCommand.Connection = this.connection; } try { if (monadAdapterFiller != null) { ExTraceGlobals.DataFlowTracer.TracePerformance<string, Guid, RunspaceState>((long)Thread.CurrentThread.ManagedThreadId, "MonadScriptExecutionContext.Execute: In runspace {1}[State:{2}], before executing command '{0}' .", monadAdapterFiller.Command.CommandText, monadAdapterFiller.Command.Connection.RunspaceProxy.InstanceId, monadAdapterFiller.Command.Connection.RunspaceProxy.State); stopwatch.Start(); } filler.Fill(table); } catch (MonadDataAdapterInvocationException ex) { if (!(ex.InnerException is ManagementObjectNotFoundException) && !(ex.InnerException is MapiObjectNotFoundException)) { throw; } } finally { if (monadAdapterFiller != null) { stopwatch.Stop(); ExTraceGlobals.DataFlowTracer.TracePerformance((long)Thread.CurrentThread.ManagedThreadId, "MonadScriptExecutionContext.Execute: In the runspace {1}[State:{2}], {3} Milliseconds are taken to finish the command {0}.", new object[] { monadAdapterFiller.Command.CommandText, monadAdapterFiller.Command.Connection.RunspaceProxy.InstanceId, monadAdapterFiller.Command.Connection.RunspaceProxy.State, stopwatch.ElapsedMilliseconds }); } this.EndExecute(filler, profile); } }
private void DetachCommandFromMonitorWarnings(MonadCommand command) { lock (this.workUnits) { WorkUnit workUnit; if (this.TryGetWorkUnit(command.CommandText, out workUnit)) { workUnit.Status = WorkUnitStatus.Completed; command.WarningReport -= this.command_WarningReport; } } }
protected override bool TryToGetPartialRefreshArgument(object[] ids, out object partialRefreshArgument) { if (1 != ids.Length) { throw new InvalidOperationException(); } MonadCommand monadCommand = this.selectCommand.Clone(); monadCommand.Parameters.AddWithValue("Identity", ids[0]); partialRefreshArgument = monadCommand; return(true); }
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); }
private MonadCommand ClonePreparedCommand() { MonadParameter[] array = new MonadParameter[this.Parameters.Count]; this.Parameters.CopyTo(array, 0); MonadParameter[] values = this.PrepareParameters(); this.Parameters.Clear(); this.Parameters.AddRange(values); MonadCommand result = this.saveCommand.Clone(); this.Parameters.Clear(); this.Parameters.AddRange(array); return(result); }
private void FillParametersFromDataRow(MonadCommand command, DataRow row) { DataRowVersion version = (row.RowState == DataRowState.Deleted) ? DataRowVersion.Original : DataRowVersion.Current; foreach (object obj in command.Parameters) { MonadParameter monadParameter = (MonadParameter)obj; if (row.Table.Columns.Contains(monadParameter.ParameterName)) { monadParameter.Value = row[monadParameter.ParameterName, version]; } } }
protected override bool TryToGetPartialRefreshArgument(object[] ids, out object partialRefreshArgument) { if (1 != ids.Length) { partialRefreshArgument = null; return(false); } MonadCommand monadCommand = this.selectCommand.Clone(); monadCommand.Parameters.Clear(); monadCommand.Parameters.AddWithValue("Identity", ids[0]); partialRefreshArgument = monadCommand; return(true); }
public bool IsCmdletAllowedInScope(MonadCommand command) { if (this.erc != null) { List <string> list = new List <string>(command.Parameters.Count); foreach (object obj in command.Parameters) { MonadParameter monadParameter = (MonadParameter)obj; list.Add(monadParameter.ParameterName); } return(this.IsCmdletAllowedInScope(command.CommandText, list.ToArray())); } return(true); }
// 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); }
protected override void OnDoRefreshWork(RefreshRequestEventArgs e) { MonadCommand monadCommand = e.Argument as MonadCommand; if (monadCommand == null || monadCommand.Parameters.Contains("Identity") || (monadCommand.Parameters.Contains("server") && !string.IsNullOrEmpty((string)monadCommand.Parameters["server"].Value))) { base.OnDoRefreshWork(e); return; } DataTable result = base.Table.Clone(); e.Result = result; e.ReportProgress(100, 100, "", null); }
public override void Run(object interactionHandler, DataRow row, DataObjectStore store) { base.OnStart(); object value = row[base.FileDataParameterName]; try { using (new OpenConnection(FormatListFileSaveSaver.connection)) { object[] value2 = null; string variableName = "FormatEnumerationLimit"; int num = -1; object variable = this.GetVariable(variableName, FormatListFileSaveSaver.connection); if (variable != null) { int.TryParse(variable.ToString(), out num); } this.SetVariable(variableName, -1, FormatListFileSaveSaver.connection); using (MonadCommand monadCommand = new MonadCommand("Format-List", FormatListFileSaveSaver.connection)) { monadCommand.Parameters.Add(new MonadParameter("InputObject", value)); value2 = monadCommand.Execute(); } using (MonadCommand monadCommand2 = new MonadCommand("Out-File", FormatListFileSaveSaver.connection)) { monadCommand2.Parameters.Add(new MonadParameter("InputObject", value2)); monadCommand2.Parameters.Add(new MonadParameter("FilePath", row[base.FilePathParameterName])); monadCommand2.Execute(); } if (num != -1) { this.SetVariable(variableName, num, FormatListFileSaveSaver.connection); } base.OnComplete(true, null); } } catch (CommandExecutionException exception) { base.OnComplete(false, exception); } catch (CmdletInvocationException exception2) { base.OnComplete(false, exception2); } catch (PipelineStoppedException exception3) { base.OnComplete(false, exception3); } }
internal SingleTaskDataHandler(MonadCommand saveCommand) { this.saveCommand = saveCommand; if (this.saveCommand == null) { throw new ArgumentNullException("saveCommand"); } this.connection = saveCommand.Connection; if (this.connection == null) { throw new ArgumentNullException("connection"); } this.fields = new ADPropertyBag(); base.DataSource = this; }
private void AttachCommandToMonitorWarnings(MonadCommand command) { lock (this.workUnits) { WorkUnit workUnit; if (!this.TryGetWorkUnit(command.CommandText, out workUnit)) { workUnit = new WorkUnit(); workUnit.Target = command; workUnit.Text = command.CommandText; this.workUnits.Add(workUnit); command.WarningReport += this.command_WarningReport; } } }
// 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: 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); }
public override void BuildParameters(DataRow row, DataObjectStore store, IList <ParameterProfile> paramInfos) { this.DataHandler.Parameters.Clear(); StringBuilder stringBuilder = new StringBuilder(); StringBuilder stringBuilder2 = new StringBuilder(); if ((bool)row[this.AutoDiscovery]) { string text = MonadCommand.FormatParameterValue(row[this.AutoDiscoveryDomain]); stringBuilder2.AppendFormat(this.AutoDiscoveryCommandText, text); stringBuilder.Append(Strings.NameValueFormat(this.AutoDiscoveryDomain, text)); } stringBuilder2.Append(this.originalCommandText); stringBuilder2.Append(" "); foreach (ParameterProfile parameterProfile in paramInfos) { if ((store.ModifiedColumns.Contains(parameterProfile.Reference) || this.Identity.Equals(parameterProfile.Name)) && parameterProfile.IsRunnable(row)) { switch (parameterProfile.ParameterType) { case ParameterType.Switched: stringBuilder2.AppendFormat("-{0} ", parameterProfile.Name); stringBuilder.AppendLine(parameterProfile.Name); break; case ParameterType.Column: case ParameterType.ModifiedColumn: { string text2 = MonadCommand.FormatParameterValue(MonadSaveTask.ConvertToParameterValue(row, parameterProfile.Reference)); stringBuilder.Append(Strings.NameValueFormat(parameterProfile.Name, text2)); if (this.Identity.Equals(parameterProfile.Name) && row[parameterProfile.Reference] is ADObjectId) { text2 = string.Format("'{0}'", ((ADObjectId)row[parameterProfile.Reference]).ObjectGuid.ToString()); } stringBuilder2.AppendFormat("-{0} {1} ", parameterProfile.Name, text2); break; } } } } this.modifiedParametersDescription = stringBuilder.ToString(); this.DataHandler.CommandText = stringBuilder2.ToString(); this.DataHandler.ClearParameterNames(); }
// 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); }
internal MonadCommand BuildProcedureWithScope(string commandText, string searchText, object[] pipeline, DataRow row, object scope) { MonadCommand monadCommand = this.InnerBuildProcedureCore(commandText, row); if (!string.IsNullOrEmpty(searchText)) { switch (this.SearchType) { case 0: monadCommand.Parameters.AddWithValue("ANR", searchText); break; case 1: monadCommand.Parameters.AddWithValue("Identity", string.Format("*{0}*", searchText)); break; } } if (!string.IsNullOrEmpty(scope as string)) { monadCommand.Parameters.AddWithValue("OrganizationalUnit", scope); } if (this.UseFilterToResolveNonId) { string pipelineFilterStringNotResolveIdentity = this.GetPipelineFilterStringNotResolveIdentity(pipeline); if (!string.IsNullOrEmpty(pipelineFilterStringNotResolveIdentity)) { string value = pipelineFilterStringNotResolveIdentity; if (monadCommand.Parameters.Contains("Filter")) { value = string.Format("({0}) -and ({1})", pipelineFilterStringNotResolveIdentity, monadCommand.Parameters["Filter"].Value); monadCommand.Parameters["Filter"].Value = value; } else { monadCommand.Parameters.AddWithValue("Filter", value); } } } return(monadCommand); }
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 bool InternalExecuteScript(string script, bool handleError, int subSteps, LocalizedString statusDescription) { bool result = false; WorkUnit workUnit = new WorkUnit(); bool newSubProgressReceived = false; int completedSubSteps = 0; try { script.TrimEnd(new char[] { '\n' }); string script2 = script.Replace("\n", "\r\n"); if (handleError) { base.WriteVerbose(Strings.ExecutingScriptNonFatal(script2)); } else { base.WriteVerbose(Strings.ExecutingScript(script2)); } script = string.Format("$error.Clear(); {0}", script); MonadCommand monadCommand = new MonadCommand(script, this.monadConnection); monadCommand.CommandType = CommandType.Text; monadCommand.ProgressReport += delegate(object sender, ProgressReportEventArgs e) { if (subSteps == 0) { return; } completedSubSteps = subSteps * e.ProgressRecord.PercentComplete / 100; newSubProgressReceived = true; }; bool flag = false; try { TaskLogger.IncreaseIndentation(); TaskLogger.LogErrorAsWarning = handleError; MonadAsyncResult monadAsyncResult = monadCommand.BeginExecute(new WorkUnit[] { workUnit }); while (!flag) { flag = monadAsyncResult.AsyncWaitHandle.WaitOne(200, false); if (newSubProgressReceived) { base.WriteProgress(this.Description, statusDescription, (this.completedSteps + completedSubSteps) * 100 / this.totalSteps); newSubProgressReceived = false; } if (base.Stopping) { break; } } if (base.Stopping) { monadCommand.Cancel(); } else { monadCommand.EndExecute(monadAsyncResult); } } catch (CommandExecutionException ex) { if (ex.InnerException != null) { throw new ScriptExecutionException(Strings.ErrorCommandExecutionException(script, ex.InnerException.ToString()), ex.InnerException); } throw; } finally { TaskLogger.DecreaseIndentation(); } this.completedSteps += subSteps; result = true; } catch (CmdletInvocationException ex2) { result = false; if (!handleError) { throw; } base.WriteVerbose(Strings.IgnoringException(ex2.ToString())); base.WriteVerbose(Strings.WillContinueProcessing); } if (workUnit.Errors.Count > 0) { result = false; int count = workUnit.Errors.Count; base.WriteVerbose(Strings.ErrorDuringTaskExecution(count)); for (int i = 0; i < count; i++) { ErrorRecord errorRecord = workUnit.Errors[i]; base.WriteVerbose(Strings.ErrorRecordReport(errorRecord.ToString(), i)); if (!handleError) { base.WriteVerbose(Strings.ErrorRecordReport(errorRecord.Exception.ToString(), i)); ScriptExecutionException exception = new ScriptExecutionException(Strings.ErrorCommandExecutionException(script, errorRecord.Exception.ToString()), errorRecord.Exception); this.WriteError(exception, errorRecord.CategoryInfo.Category, errorRecord.TargetObject, false); } } if (handleError) { base.WriteVerbose(Strings.WillIgnoreNoncriticalErrors); base.WriteVerbose(Strings.WillContinueProcessing); } } return(result); }
protected override void InternalProcessRecord() { TaskLogger.LogEnter(); this.datetime = ((DateTime)ExDateTime.Now).ToString("yyyyMMdd-HHmmss"); try { string value = "LOGVERBOSE=1 TARGETDIR=\"" + this.InstallPath + "\""; Dictionary <string, bool> dictionary = new Dictionary <string, bool>(); Dictionary <string, bool> dictionary2 = new Dictionary <string, bool>(); int num = 0; for (int i = 0; i < this.LanguagePacksToInstall.Length; i++) { bool flag = Convert.ToBoolean(this.LPServerFlags[i]); dictionary.Add(this.LanguagePacksToInstall[i], flag); if (flag) { num++; } flag = Convert.ToBoolean(this.LPClientFlags[i]); dictionary2.Add(this.LanguagePacksToInstall[i], flag); if (flag) { num++; } } int num2 = num * 2; if (this.SourceIsBundle) { num2 += this.LanguagePacksToInstall.Length; } int num3 = 0; foreach (string text in this.LanguagePacksToInstall) { int lcid = CultureInfo.GetCultureInfo(text).LCID; string text2 = ""; if (this.SourceIsBundle) { TaskLogger.Log(Strings.ExtractingLang(text)); base.WriteProgress(this.Description, Strings.ExtractingLang(text), (int)((double)num3 * 100.0 / (double)num2 + 0.5)); DirectoryInfo directoryInfo = Directory.CreateDirectory(Path.Combine(Path.GetTempPath(), Path.GetFileNameWithoutExtension(this.LangPackPath.PathName))); string text3 = text + "\\"; EmbeddedCabWrapper.ExtractFiles(this.LangPackPath.PathName, directoryInfo.FullName, text3); text2 = directoryInfo.FullName + '\\' + text3; num3++; } else { text2 = Path.Combine(this.LangPackPath.PathName, text); } string text4 = Path.Combine(text2, "ClientLanguagePack.msi"); if (dictionary2[text] && File.Exists(text4)) { TaskLogger.Log(Strings.UninstallOldMSIFor(text, "client")); base.WriteProgress(this.Description, Strings.UninstallOldMSIFor(text, "client"), (int)((double)num3 * 100.0 / (double)num2 + 0.5)); using (MonadCommand monadCommand = new MonadCommand("Uninstall-MsiPackage", this.monadConnection)) { string value2 = this.CreateMsilogPathname("Uninstall", "Client", text); monadCommand.Parameters.AddWithValue("LogFile", value2); Guid productCode = MsiUtility.GetProductCode(text4); monadCommand.Parameters.AddWithValue("ProductCode", productCode); monadCommand.Execute(); } num3++; TaskLogger.Log(Strings.InstallingMSIFor(text, "client")); base.WriteProgress(this.Description, Strings.InstallingMSIFor(text, "client"), (int)((double)num3 * 100.0 / (double)num2 + 0.5)); using (MonadCommand monadCommand2 = new MonadCommand("Install-MsiPackage", this.monadConnection)) { monadCommand2.Parameters.AddWithValue("PackagePath", text4); string value3 = this.CreateMsilogPathname("Install", "Client", text); monadCommand2.Parameters.AddWithValue("LogFile", value3); monadCommand2.Parameters.AddWithValue("Features", new string[] { "AdminTools", "Mailbox", "ClientAccess", "Gateway", "Bridgehead", "UnifiedMessaging", "ClientLanguagePack" }); monadCommand2.Parameters.AddWithValue("PropertyValues", value); monadCommand2.Execute(); } num3++; } text4 = Path.Combine(text2, "ServerLanguagePack.msi"); if (dictionary[text] && File.Exists(text4)) { TaskLogger.Log(Strings.UninstallOldMSIFor(text, "server")); base.WriteProgress(this.Description, Strings.UninstallOldMSIFor(text, "server"), (int)((double)num3 * 100.0 / (double)num2 + 0.5)); using (MonadCommand monadCommand3 = new MonadCommand("Uninstall-MsiPackage", this.monadConnection)) { string value4 = this.CreateMsilogPathname("Uninstall", "Server", text); monadCommand3.Parameters.AddWithValue("LogFile", value4); Guid productCode2 = MsiUtility.GetProductCode(text4); monadCommand3.Parameters.AddWithValue("ProductCode", productCode2); monadCommand3.Execute(); } num3++; TaskLogger.Log(Strings.InstallingMSIFor(text, "server")); base.WriteProgress(this.Description, Strings.InstallingMSIFor(text, "server"), (int)((double)num3 * 100.0 / (double)num2 + 0.5)); using (MonadCommand monadCommand4 = new MonadCommand("Install-MsiPackage", this.monadConnection)) { monadCommand4.Parameters.AddWithValue("PackagePath", text4); string value5 = this.CreateMsilogPathname("Install", "Server", text); monadCommand4.Parameters.AddWithValue("LogFile", value5); monadCommand4.Parameters.AddWithValue("Features", new string[] { "AdminTools", "Mailbox", "ClientAccess", "Gateway", "Bridgehead", "UnifiedMessaging", "ServerLanguagePack" }); monadCommand4.Parameters.AddWithValue("PropertyValues", value); monadCommand4.Execute(); } num3++; } if (this.SourceIsBundle) { try { Directory.Delete(text2, true); } catch (IOException e) { TaskLogger.LogError(e); } } } } finally { base.WriteProgress(this.Description, Strings.ProgressStatusCompleted, 100); TaskLogger.LogExit(); } }