Exemple #1
0
        protected override void ProcessRecord()
        {
            Collection <string> collection  = UpdateData.Glob(base.PrependPath, "FormatPrependPathException", this);
            Collection <string> collection2 = UpdateData.Glob(base.AppendPath, "FormatAppendPathException", this);

            if (((base.PrependPath.Length <= 0) && (base.AppendPath.Length <= 0)) || ((collection.Count != 0) || (collection2.Count != 0)))
            {
                string updateFormatDataAction = UpdateDataStrings.UpdateFormatDataAction;
                string updateTarget           = UpdateDataStrings.UpdateTarget;
                if (base.Context.RunspaceConfiguration != null)
                {
                    for (int i = collection.Count - 1; i >= 0; i--)
                    {
                        string target = string.Format(Thread.CurrentThread.CurrentCulture, updateTarget, new object[] { collection[i] });
                        if (base.ShouldProcess(target, updateFormatDataAction))
                        {
                            base.Context.RunspaceConfiguration.Formats.Prepend(new FormatConfigurationEntry(collection[i]));
                        }
                    }
                    foreach (string str4 in collection2)
                    {
                        string str5 = string.Format(Thread.CurrentThread.CurrentCulture, updateTarget, new object[] { str4 });
                        if (base.ShouldProcess(str5, updateFormatDataAction))
                        {
                            base.Context.RunspaceConfiguration.Formats.Append(new FormatConfigurationEntry(str4));
                        }
                    }
                    try
                    {
                        base.Context.CurrentRunspace.RunspaceConfiguration.Formats.Update(true);
                        return;
                    }
                    catch (RuntimeException exception)
                    {
                        base.WriteError(new ErrorRecord(exception, "FormatXmlUpdateException", ErrorCategory.InvalidOperation, null));
                        return;
                    }
                }
                if (base.Context.InitialSessionState != null)
                {
                    if (base.Context.InitialSessionState.DisableFormatUpdates)
                    {
                        throw new PSInvalidOperationException(UpdateDataStrings.FormatUpdatesDisabled);
                    }
                    HashSet <string> set = new HashSet <string>(StringComparer.CurrentCultureIgnoreCase);
                    Collection <SessionStateFormatEntry> collection3 = new Collection <SessionStateFormatEntry>();
                    for (int j = collection.Count - 1; j >= 0; j--)
                    {
                        string str6 = string.Format(Thread.CurrentThread.CurrentCulture, updateTarget, new object[] { collection[j] });
                        if (base.ShouldProcess(str6, updateFormatDataAction) && !set.Contains(collection[j]))
                        {
                            set.Add(collection[j]);
                            collection3.Add(new SessionStateFormatEntry(collection[j]));
                        }
                    }
                    foreach (SessionStateFormatEntry entry in base.Context.InitialSessionState.Formats)
                    {
                        if (entry.FileName != null)
                        {
                            if (!set.Contains(entry.FileName))
                            {
                                set.Add(entry.FileName);
                                collection3.Add(entry);
                            }
                        }
                        else
                        {
                            collection3.Add(entry);
                        }
                    }
                    foreach (string str7 in collection2)
                    {
                        string str8 = string.Format(Thread.CurrentThread.CurrentCulture, updateTarget, new object[] { str7 });
                        if (base.ShouldProcess(str8, updateFormatDataAction) && !set.Contains(str7))
                        {
                            set.Add(str7);
                            collection3.Add(new SessionStateFormatEntry(str7));
                        }
                    }
                    try
                    {
                        base.Context.InitialSessionState.Formats.Clear();
                        Collection <PSSnapInTypeAndFormatErrors> mshsnapins = new Collection <PSSnapInTypeAndFormatErrors>();
                        foreach (SessionStateFormatEntry entry2 in collection3)
                        {
                            string       fileName = entry2.FileName;
                            PSSnapInInfo pSSnapIn = entry2.PSSnapIn;
                            if ((pSSnapIn != null) && !string.IsNullOrEmpty(pSSnapIn.Name))
                            {
                                fileName = pSSnapIn.Name;
                            }
                            if (entry2.Formattable != null)
                            {
                                PSInvalidOperationException exception2 = new PSInvalidOperationException(UpdateDataStrings.CannotUpdateFormatWithFormatTable);
                                base.WriteError(new ErrorRecord(exception2, "CannotUpdateFormatWithFormatTable", ErrorCategory.InvalidOperation, null));
                            }
                            else
                            {
                                if (entry2.FormatData != null)
                                {
                                    mshsnapins.Add(new PSSnapInTypeAndFormatErrors(fileName, entry2.FormatData));
                                }
                                else
                                {
                                    mshsnapins.Add(new PSSnapInTypeAndFormatErrors(fileName, entry2.FileName));
                                }
                                base.Context.InitialSessionState.Formats.Add(entry2);
                            }
                        }
                        if (mshsnapins.Count > 0)
                        {
                            base.Context.FormatDBManager.UpdateDataBase(mshsnapins, base.Context.AuthorizationManager, base.Context.EngineHostInterface, false);
                            FormatAndTypeDataHelper.ThrowExceptionOnError("ErrorsUpdatingFormats", null, mshsnapins, RunspaceConfigurationCategory.Formats);
                        }
                    }
                    catch (RuntimeException exception3)
                    {
                        base.WriteError(new ErrorRecord(exception3, "FormatXmlUpdateException", ErrorCategory.InvalidOperation, null));
                    }
                }
            }
        }
Exemple #2
0
        private void ProcessTypeFiles()
        {
            Collection <string> collection  = UpdateData.Glob(base.PrependPath, "TypesPrependPathException", this);
            Collection <string> collection2 = UpdateData.Glob(base.AppendPath, "TypesAppendPathException", this);

            if (((base.PrependPath.Length <= 0) && (base.AppendPath.Length <= 0)) || ((collection.Count != 0) || (collection2.Count != 0)))
            {
                string updateTypeDataAction = UpdateDataStrings.UpdateTypeDataAction;
                string updateTarget         = UpdateDataStrings.UpdateTarget;
                if (base.Context.RunspaceConfiguration != null)
                {
                    for (int i = collection.Count - 1; i >= 0; i--)
                    {
                        string target = string.Format(CultureInfo.InvariantCulture, updateTarget, new object[] { collection[i] });
                        if (base.ShouldProcess(target, updateTypeDataAction))
                        {
                            base.Context.RunspaceConfiguration.Types.Prepend(new TypeConfigurationEntry(collection[i]));
                        }
                    }
                    foreach (string str4 in collection2)
                    {
                        string str5 = string.Format(CultureInfo.InvariantCulture, updateTarget, new object[] { str4 });
                        if (base.ShouldProcess(str5, updateTypeDataAction))
                        {
                            base.Context.RunspaceConfiguration.Types.Append(new TypeConfigurationEntry(str4));
                        }
                    }
                    try
                    {
                        base.Context.CurrentRunspace.RunspaceConfiguration.Types.Update(true);
                        return;
                    }
                    catch (RuntimeException exception)
                    {
                        base.WriteError(new ErrorRecord(exception, "TypesXmlUpdateException", ErrorCategory.InvalidOperation, null));
                        return;
                    }
                }
                if (base.Context.InitialSessionState != null)
                {
                    HashSet <string> set = new HashSet <string>(StringComparer.CurrentCultureIgnoreCase);
                    Collection <SessionStateTypeEntry> collection3 = new Collection <SessionStateTypeEntry>();
                    for (int j = collection.Count - 1; j >= 0; j--)
                    {
                        string str6 = string.Format(CultureInfo.InvariantCulture, updateTarget, new object[] { collection[j] });
                        string item = ModuleCmdletBase.ResolveRootedFilePath(collection[j], base.Context) ?? collection[j];
                        if (base.ShouldProcess(str6, updateTypeDataAction) && !set.Contains(item))
                        {
                            set.Add(item);
                            collection3.Add(new SessionStateTypeEntry(collection[j]));
                        }
                    }
                    foreach (SessionStateTypeEntry entry in base.Context.InitialSessionState.Types)
                    {
                        if (entry.FileName != null)
                        {
                            string str8 = ModuleCmdletBase.ResolveRootedFilePath(entry.FileName, base.Context) ?? entry.FileName;
                            if (!set.Contains(str8))
                            {
                                set.Add(str8);
                                collection3.Add(entry);
                            }
                        }
                        else
                        {
                            collection3.Add(entry);
                        }
                    }
                    foreach (string str9 in collection2)
                    {
                        string str10 = string.Format(CultureInfo.InvariantCulture, updateTarget, new object[] { str9 });
                        string str11 = ModuleCmdletBase.ResolveRootedFilePath(str9, base.Context) ?? str9;
                        if (base.ShouldProcess(str10, updateTypeDataAction) && !set.Contains(str11))
                        {
                            set.Add(str11);
                            collection3.Add(new SessionStateTypeEntry(str9));
                        }
                    }
                    base.Context.InitialSessionState.Types.Clear();
                    Collection <string> errors = new Collection <string>();
                    bool clearTable            = true;
                    foreach (SessionStateTypeEntry entry2 in collection3)
                    {
                        try
                        {
                            if (entry2.TypeTable != null)
                            {
                                PSInvalidOperationException exception2 = new PSInvalidOperationException(UpdateDataStrings.CannotUpdateTypeWithTypeTable);
                                base.WriteError(new ErrorRecord(exception2, "CannotUpdateTypeWithTypeTable", ErrorCategory.InvalidOperation, null));
                                continue;
                            }
                            if (entry2.FileName != null)
                            {
                                bool flag2;
                                base.Context.TypeTable.Update(entry2.FileName, errors, clearTable, base.Context.AuthorizationManager, base.Context.InitialSessionState.Host, out flag2);
                            }
                            else
                            {
                                base.Context.TypeTable.Update(entry2.TypeData, errors, entry2.IsRemove, clearTable);
                            }
                        }
                        catch (RuntimeException exception3)
                        {
                            base.WriteError(new ErrorRecord(exception3, "TypesXmlUpdateException", ErrorCategory.InvalidOperation, null));
                        }
                        base.Context.InitialSessionState.Types.Add(entry2);
                        if (errors.Count > 0)
                        {
                            foreach (string str12 in errors)
                            {
                                RuntimeException exception4 = new RuntimeException(str12);
                                base.WriteError(new ErrorRecord(exception4, "TypesXmlUpdateException", ErrorCategory.InvalidOperation, null));
                            }
                            errors.Clear();
                        }
                        clearTable = false;
                    }
                }
            }
        }
Exemple #3
0
 protected override void ProcessRecord()
 {
     if (base.ParameterSetName == "RemoveFileSet")
     {
         string removeTypeFileAction    = UpdateDataStrings.RemoveTypeFileAction;
         string updateTarget            = UpdateDataStrings.UpdateTarget;
         Collection <string> collection = UpdateData.Glob(this.typeFiles, "TypePathException", this);
         if (collection.Count != 0)
         {
             Dictionary <string, List <int> > fileNameToIndexMap = new Dictionary <string, List <int> >(StringComparer.OrdinalIgnoreCase);
             List <int> list = new List <int>();
             if (base.Context.RunspaceConfiguration != null)
             {
                 for (int i = 0; i < base.Context.RunspaceConfiguration.Types.Count; i++)
                 {
                     string fileName = base.Context.RunspaceConfiguration.Types[i].FileName;
                     if (fileName != null)
                     {
                         ConstructFileToIndexMap(fileName, i, fileNameToIndexMap);
                     }
                 }
             }
             else if (base.Context.InitialSessionState != null)
             {
                 for (int j = 0; j < base.Context.InitialSessionState.Types.Count; j++)
                 {
                     string filePath = base.Context.InitialSessionState.Types[j].FileName;
                     if (filePath != null)
                     {
                         filePath = ModuleCmdletBase.ResolveRootedFilePath(filePath, base.Context) ?? filePath;
                         ConstructFileToIndexMap(filePath, j, fileNameToIndexMap);
                     }
                 }
             }
             foreach (string str5 in collection)
             {
                 string target = string.Format(CultureInfo.InvariantCulture, updateTarget, new object[] { str5 });
                 if (base.ShouldProcess(target, removeTypeFileAction))
                 {
                     List <int> list2;
                     if (fileNameToIndexMap.TryGetValue(str5, out list2))
                     {
                         list.AddRange(list2);
                     }
                     else
                     {
                         base.WriteError(this.NewError("TypeFileNotExistsInCurrentSession", "TypeFileNotExistsInCurrentSession", null, new object[] { str5 }));
                     }
                 }
             }
             if (list.Count > 0)
             {
                 list.Sort();
                 for (int k = list.Count - 1; k >= 0; k--)
                 {
                     if (base.Context.RunspaceConfiguration != null)
                     {
                         base.Context.RunspaceConfiguration.Types.RemoveItem(list[k]);
                     }
                     else if (base.Context.InitialSessionState != null)
                     {
                         base.Context.InitialSessionState.Types.RemoveItem(list[k]);
                     }
                 }
                 try
                 {
                     if (base.Context.RunspaceConfiguration != null)
                     {
                         base.Context.RunspaceConfiguration.Types.Update();
                     }
                     else if (base.Context.InitialSessionState != null)
                     {
                         bool refreshTypeAndFormatSetting = base.Context.InitialSessionState.RefreshTypeAndFormatSetting;
                         try
                         {
                             base.Context.InitialSessionState.RefreshTypeAndFormatSetting = true;
                             base.Context.InitialSessionState.UpdateTypes(base.Context, false, false);
                         }
                         finally
                         {
                             base.Context.InitialSessionState.RefreshTypeAndFormatSetting = refreshTypeAndFormatSetting;
                         }
                     }
                 }
                 catch (RuntimeException exception)
                 {
                     base.WriteError(new ErrorRecord(exception, "TypesFileRemoveException", ErrorCategory.InvalidOperation, null));
                 }
             }
         }
     }
     else
     {
         string removeTypeDataAction = UpdateDataStrings.RemoveTypeDataAction;
         string removeTypeDataTarget = UpdateDataStrings.RemoveTypeDataTarget;
         string typeName             = null;
         if (base.ParameterSetName == "RemoveTypeDataSet")
         {
             typeName = this.typeData.TypeName;
         }
         else
         {
             if (string.IsNullOrWhiteSpace(this.typeName))
             {
                 base.ThrowTerminatingError(this.NewError("TargetTypeNameEmpty", "TargetTypeNameEmpty", this.typeName, new object[0]));
             }
             typeName = this.typeName;
         }
         System.Management.Automation.Runspaces.TypeData type = new System.Management.Automation.Runspaces.TypeData(typeName);
         string str10 = string.Format(CultureInfo.InvariantCulture, removeTypeDataTarget, new object[] { typeName });
         if (base.ShouldProcess(str10, removeTypeDataAction))
         {
             try
             {
                 Collection <string> errors = new Collection <string>();
                 base.Context.TypeTable.Update(type, errors, true, false);
                 if (errors.Count > 0)
                 {
                     foreach (string str11 in errors)
                     {
                         RuntimeException exception2 = new RuntimeException(str11);
                         base.WriteError(new ErrorRecord(exception2, "TypesDynamicRemoveException", ErrorCategory.InvalidOperation, null));
                     }
                 }
                 else if (base.Context.RunspaceConfiguration != null)
                 {
                     base.Context.RunspaceConfiguration.Types.Append(new TypeConfigurationEntry(type, true));
                 }
                 else if (base.Context.InitialSessionState != null)
                 {
                     base.Context.InitialSessionState.Types.Add(new SessionStateTypeEntry(type, true));
                 }
             }
             catch (RuntimeException exception3)
             {
                 base.WriteError(new ErrorRecord(exception3, "TypesDynamicRemoveException", ErrorCategory.InvalidOperation, null));
             }
         }
     }
 }