Esempio n. 1
0
        /// <summary>
        /// Converts a <see cref="JObject"/> to a <see cref="PSObject"/>
        /// </summary>
        /// <param name="jtoken">The <see cref="JObject"/></param>
        /// <param name="objectType">The type of the object.</param>
        internal static PSObject ToPsObject(this JToken jtoken, string objectType = null)
        {
            if (jtoken == null)
            {
                return null;
            }

            if (jtoken.Type != JTokenType.Object)
            {
                return new PSObject(JTokenExtensions.ConvertPropertyValueForPsObject(propertyValue: jtoken));
            }

            var jobject = (JObject)jtoken;
            var psObject = new PSObject();

            if (!string.IsNullOrWhiteSpace(objectType))
            {
                psObject.TypeNames.Add(objectType);
            }

            foreach (var property in jobject.Properties())
            {
                psObject.Properties.Add(new PSNoteProperty(
                    name: property.Name,
                    value: JTokenExtensions.ConvertPropertyValueForPsObject(propertyValue: property.Value)));
            }

            return psObject;
        }
Esempio n. 2
0
        private static void ShowHelpWindow(PSObject helpObj, PSCmdlet cmdlet)
        {
            Window ownerWindow = ShowCommandHelper.GetHostWindow(cmdlet);
            if (ownerWindow != null)
            {
                ownerWindow.Dispatcher.Invoke(
                    new SendOrPostCallback(
                        delegate(object ignored)
                        {
                            HelpWindow helpWindow = new HelpWindow(helpObj);
                            helpWindow.Owner = ownerWindow;
                            helpWindow.Show();

                            helpWindow.Closed += new EventHandler(delegate(object sender, EventArgs e) { ownerWindow.Focus(); });
                        }),
                        String.Empty);
                return;
            }

            Thread guiThread = new Thread(
            (ThreadStart)delegate
            {
                HelpWindow helpWindow = new HelpWindow(helpObj);
                helpWindow.ShowDialog();
            });
            guiThread.SetApartmentState(ApartmentState.STA);
            guiThread.Start();
        }
 protected virtual PSObject SetVirtualMachineState(PSObject vm, string state)
 {
     PowerShell.Commands.Clear();
     PowerShell.AddCommand(string.Format("{0}-WAPackVM", state)).AddParameter("VM", vm);
     var updatedVm = PowerShell.InvokeAndAssertForNoErrors();
     return updatedVm[0];
 }
Esempio n. 4
0
 private WideControlEntryDefinition GetActiveWideControlEntryDefinition(WideControlBody wideBody, PSObject so)
 {
     ConsolidatedString internalTypeNames = so.InternalTypeNames;
     TypeMatch match = new TypeMatch(base.expressionFactory, base.dataBaseInfo.db, internalTypeNames);
     foreach (WideControlEntryDefinition definition in wideBody.optionalEntryList)
     {
         if (match.PerfectMatch(new TypeMatchItem(definition, definition.appliesTo)))
         {
             return definition;
         }
     }
     if (match.BestMatch != null)
     {
         return (match.BestMatch as WideControlEntryDefinition);
     }
     Collection<string> typeNames = Deserializer.MaskDeserializationPrefix(internalTypeNames);
     if (typeNames != null)
     {
         match = new TypeMatch(base.expressionFactory, base.dataBaseInfo.db, typeNames);
         foreach (WideControlEntryDefinition definition2 in wideBody.optionalEntryList)
         {
             if (match.PerfectMatch(new TypeMatchItem(definition2, definition2.appliesTo)))
             {
                 return definition2;
             }
         }
         if (match.BestMatch != null)
         {
             return (match.BestMatch as WideControlEntryDefinition);
         }
     }
     return wideBody.defaultEntryDefinition;
 }
Esempio n. 5
0
 internal override void Deserialize(PSObject so, FormatObjectDeserializer deserializer)
 {
     base.Deserialize(so, deserializer);
     this.leftIndentation = deserializer.DeserializeIntMemberVariable(so, "leftIndentation");
     this.rightIndentation = deserializer.DeserializeIntMemberVariable(so, "rightIndentation");
     this.firstLine = deserializer.DeserializeIntMemberVariable(so, "firstLine");
 }
Esempio n. 6
0
 private static void EncodeAndAddReturnValue(PSObject psObject, object returnValue)
 {
     if (returnValue != null)
     {
         RemoteHostEncoder.EncodeAndAddAsProperty(psObject, "mr", returnValue);
     }
 }
Esempio n. 7
0
        protected override void ProcessRecord()
        {
            base.ProcessRecord();
            string Filter = "(&(objectCategory=group)(name=" + Name + "))";
            string Scope = "Subtree";
            string[] Properties = null;

            SearchResultCollection AdGroupObject = Utilities.Functions.QueryAD(Path, Filter, Scope, Properties);
            foreach (SearchResult Group in AdGroupObject)
            {
                foreach (string Member in Group.Properties["member"])
                {
                    foreach (SearchResult AdObject in (Utilities.Functions.QueryAD("LDAP://" + Member, "", "Base", null)))
                    {
                        WriteVerbose("Create PowerShell object to hold return values");
                        PSObject objReturn = new PSObject();
                        WriteVerbose("Add AdObject.Properties to PowerShell object");
                        foreach (string AdProperty in AdObject.Properties.PropertyNames)
                        {
                            WriteDebug("Add property : " + AdProperty);
                            objReturn.Properties.Add(new PSNoteProperty(AdProperty, (AdObject.Properties[AdProperty])[0]));
                        }
                        WriteObject(objReturn);
                    }
                }
            }
        }
Esempio n. 8
0
 internal static List<MshResolvedExpressionParameterAssociation> ExpandAll(PSObject target)
 {
     List<string> propertyNamesFromView = GetPropertyNamesFromView(target, PSMemberViewTypes.Adapted);
     List<string> list2 = GetPropertyNamesFromView(target, PSMemberViewTypes.Base);
     List<string> collection = GetPropertyNamesFromView(target, PSMemberViewTypes.Extended);
     List<string> list4 = new List<string>();
     if (propertyNamesFromView.Count != 0)
     {
         list4 = propertyNamesFromView;
     }
     else
     {
         list4 = list2;
     }
     list4.AddRange(collection);
     Dictionary<string, object> dictionary = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
     List<MshResolvedExpressionParameterAssociation> list5 = new List<MshResolvedExpressionParameterAssociation>();
     foreach (string str in list4)
     {
         if (!dictionary.ContainsKey(str))
         {
             dictionary.Add(str, null);
             MshExpression expression = new MshExpression(str, true);
             list5.Add(new MshResolvedExpressionParameterAssociation(null, expression));
         }
     }
     return list5;
 }
Esempio n. 9
0
 public Collection<FormatData> Process(PSObject psobj)
 {
     // unroll one level. But more than LanguagePrimitives would unroll!
     var enumerator = LanguagePrimitives.GetEnumerator(psobj);
     if (enumerator == null)
     {
         var baseObj = PSObject.Unwrap(psobj);
         var enumerable = baseObj as IEnumerable;
         if (!(baseObj is string) && enumerable != null)
         {
             enumerator = enumerable.GetEnumerator();
         }
     }
     if (enumerator == null)
     {
         return ProcessObject(psobj);
     }
     var results = new List<FormatData>();
     while (enumerator.MoveNext())
     {
         var curPSobj = PSObject.AsPSObject(enumerator.Current);
         results.AddRange(ProcessObject(curPSobj));
     }
     return new Collection<FormatData>(results);
 }
Esempio n. 10
0
 public DscResourceClass(string name, string module, int index)
 {
     Name = name;
     Module = module;
     Index = index;
     _dscResourceItem = DscResourceAddOn.allDscResources[index - 1];//-1 since the output index is 1 more than the 0 indexed array
 }
Esempio n. 11
0
        public IEnumerable<String> ProcessRecord(PSObject record)
        {
            if (record == null)
            {
                yield break;
            }

            if (_raw)
            {
                yield return record.ToString();
            }
            else
            {
                if (_pipeline == null)
                {
                    _pipeline = CreatePipeline();
                    _pipeline.InvokeAsync();
                }

                _pipeline.Input.Write(record);

                foreach (PSObject result in _pipeline.Output.NonBlockingRead())
                {
                    yield return result.ToString();
                }
            }
        }
Esempio n. 12
0
        public PSObjectProxy(PSObject target)
        {
            if (target == null)
                throw new ArgumentNullException("target");

            m_target = target;
        }
Esempio n. 13
0
 internal static void EnsurePropertyInfoPathExists(PSObject psObject, string[] path)
 {
     if (path.Length > 0)
     {
         for (int i = 0; i < path.Length; i++)
         {
             string name = path[i];
             PSPropertyInfo member = psObject.Properties[name];
             if (member == null)
             {
                 object obj2 = (i < (path.Length - 1)) ? new PSObject() : null;
                 member = new PSNoteProperty(name, obj2);
                 psObject.Properties.Add(member);
             }
             if (i == (path.Length - 1))
             {
                 return;
             }
             if ((member.Value == null) || !(member.Value is PSObject))
             {
                 member.Value = new PSObject();
             }
             psObject = (PSObject) member.Value;
         }
     }
 }
Esempio n. 14
0
 internal static void ToPSObjectForRemoting(CommandInfo commandInfo, PSObject psObject)
 {
     RemotingEncoder.ValueGetterDelegate<CommandTypes> valueGetter = null;
     RemotingEncoder.ValueGetterDelegate<string> delegate3 = null;
     RemotingEncoder.ValueGetterDelegate<string> delegate4 = null;
     RemotingEncoder.ValueGetterDelegate<SessionStateEntryVisibility> delegate5 = null;
     if (commandInfo != null)
     {
         if (valueGetter == null)
         {
             valueGetter = () => commandInfo.CommandType;
         }
         RemotingEncoder.AddNoteProperty<CommandTypes>(psObject, "CommandInfo_CommandType", valueGetter);
         if (delegate3 == null)
         {
             delegate3 = () => commandInfo.Definition;
         }
         RemotingEncoder.AddNoteProperty<string>(psObject, "CommandInfo_Definition", delegate3);
         if (delegate4 == null)
         {
             delegate4 = () => commandInfo.Name;
         }
         RemotingEncoder.AddNoteProperty<string>(psObject, "CommandInfo_Name", delegate4);
         if (delegate5 == null)
         {
             delegate5 = () => commandInfo.Visibility;
         }
         RemotingEncoder.AddNoteProperty<SessionStateEntryVisibility>(psObject, "CommandInfo_Visibility", delegate5);
     }
 }
Esempio n. 15
0
        //todo
        protected override void ProcessRecord()
        {
            foreach (String _path in Path)
            {
                StreamReader _file = new StreamReader(_path);
                PSObject _obj = new PSObject();

                if (_file.Peek() == '#')
                {
                    String _line = _file.ReadLine();
                    if (_line.StartsWith("#TYPE"))
                    {
                        _obj.TypeNames.Add(_line.Substring(5).Trim());
                    }
                }

                // Hold the names of the properties, the capacity is pretty arbitrary
                //List<String> _names = new List<String>(16);

                //bool inValues = false;

                while (!_file.EndOfStream)
                {
                    char _ch = (char)_file.Read();
                }
                /* if ((_ch == ',')
                 {
                     _obj.Properties.Add(new PSNoteProperty());
                 } */
            }
        }
Esempio n. 16
0
        internal static List<MshResolvedExpressionParameterAssociation> SetupActiveProperties(List<MshParameter> rawMshParameterList,
                                                   PSObject target, MshExpressionFactory expressionFactory)
        {
            // check if we received properties from the command line
            if (rawMshParameterList != null && rawMshParameterList.Count > 0)
            {
                return AssociationManager.ExpandParameters(rawMshParameterList, target);
            }

            // we did not get any properties:
            //try to get properties from the default property set of the object
            List<MshResolvedExpressionParameterAssociation> activeAssociationList = AssociationManager.ExpandDefaultPropertySet(target, expressionFactory);

            if (activeAssociationList.Count > 0)
            {
                // we got a valid set of properties from the default property set..add computername for
                // remoteobjects (if available)
                if (PSObjectHelper.ShouldShowComputerNameProperty(target))
                {
                    activeAssociationList.Add(new MshResolvedExpressionParameterAssociation(null,
                        new MshExpression(RemotingConstants.ComputerNameNoteProperty)));
                }

                return activeAssociationList;
            }

            // we failed to get anything from the default property set
            // just get all the properties
            activeAssociationList = AssociationManager.ExpandAll(target);
            // Remove PSComputerName and PSShowComputerName from the display as needed.
            AssociationManager.HandleComputerNameProperties(target, activeAssociationList);

            return activeAssociationList;
        }
Esempio n. 17
0
 protected override void ProcessRecord()
 {
     base.ProcessRecord();
     if (Globals.authToken != null)
     {
         _serverProxy = new ServerCommandProxy(Globals.ComputerName, Globals.Port, Globals.authToken);
         try
         {
             _serverProxy.AddAdminAccessUser(UserName);
             PSObject returnAddPcutAdminAccessUser = new PSObject();
             returnAddPcutAdminAccessUser.Properties.Add(new PSNoteProperty("Username", UserName));
             returnAddPcutAdminAccessUser.Properties.Add(new PSNoteProperty("AdminAccess", true));
             WriteObject(returnAddPcutAdminAccessUser);
         }
         catch (XmlRpcFaultException fex)
         {
             ErrorRecord errRecord = new ErrorRecord(new Exception(fex.Message, fex.InnerException), fex.FaultString, ErrorCategory.NotSpecified, fex);
             WriteError(errRecord);
         }
     }
     else
     {
         WriteObject("Please run Connect-PcutServer in order to establish connection.");
     }
 }
Esempio n. 18
0
 public virtual ErrorFormatEntryData GenerateErrorFormatEntry(PSObject errorData)
 {
     ErrorRecord errorRecord;
     if (errorData.BaseObject is ErrorRecord)
     {
         errorRecord = (ErrorRecord)errorData.BaseObject;
     }
     else if (errorData.BaseObject is IContainsErrorRecord)
     {
         errorRecord = ((IContainsErrorRecord)errorData).ErrorRecord;
     }
     else if (errorData.BaseObject is Exception)
     {
         errorRecord = new ErrorRecord((Exception)errorData.BaseObject, "Exception",
                                       ErrorCategory.NotSpecified, null);
     }
     else
     {
         var msg = "Cannot generate ErrorFormatEntry from non-error. This is a bug, please report this issue!";
         throw new NotImplementedException(msg);
     }
     var message = errorRecord.Exception == null ? "Unknown Error" : errorRecord.Exception.Message;
     var entry = new ErrorFormatEntryData(Shape, message, errorRecord.CategoryInfo.ToString(),
                                     errorRecord.FullyQualifiedErrorId);
     entry.WriteToErrorStream = errorData.WriteToErrorStream;
     return entry;
 }
Esempio n. 19
0
        /// <summary>
        /// compute the string value of the grouping property
        /// </summary>
        /// <param name="so">object to use to compute the property value</param>
        /// <returns>true if there was an update</returns>
        internal bool UpdateGroupingKeyValue(PSObject so)
        {
            if (_groupingKeyExpression == null)
                return false;

            List<MshExpressionResult> results = _groupingKeyExpression.GetValues(so);

            // if we have more that one match, we have to select the first one
            if (results.Count > 0 && results[0].Exception == null)
            {
                // no exception got thrown, so we can update
                object newValue = results[0].Result;
                object oldValue = _currentGroupingKeyPropertyValue;

                _currentGroupingKeyPropertyValue = newValue;

                // now do the comparison
                bool update = !(IsEqual(_currentGroupingKeyPropertyValue, oldValue) ||
                                IsEqual(oldValue, _currentGroupingKeyPropertyValue));

                if (update && _label == null)
                {
                    _groupingKeyDisplayName = results[0].ResolvedExpression.ToString();
                }
                return update;
            }

            // we had no matches or we could not get the value:
            // NOTICE: we need to do this to avoid starting a new group every time 
            // there is a failure to read the grouping property.
            // For example, for AD, there are objects that throw when trying
            // to read the "distinguishedName" property (used by the brokered property "ParentPath)
            return false;
        }
Esempio n. 20
0
 internal PSEventArgs(string computerName, Guid runspaceId, int eventIdentifier, string sourceIdentifier, object sender, object[] originalArgs, PSObject additionalData)
 {
     if (originalArgs != null)
     {
         foreach (object obj2 in originalArgs)
         {
             EventArgs args = obj2 as EventArgs;
             if (args != null)
             {
                 this.sourceEventArgs = args;
                 break;
             }
             if (ForwardedEventArgs.IsRemoteSourceEventArgs(obj2))
             {
                 this.sourceEventArgs = new ForwardedEventArgs((PSObject) obj2);
                 break;
             }
         }
     }
     this.computerName = computerName;
     this.runspaceId = runspaceId;
     this.eventIdentifier = eventIdentifier;
     this.sender = sender;
     this.sourceArgs = originalArgs;
     this.sourceIdentifier = sourceIdentifier;
     this.timeGenerated = DateTime.Now;
     this.data = additionalData;
     this.forwardEvent = false;
 }
Esempio n. 21
0
 internal override void Deserialize(PSObject so, FormatObjectDeserializer deserializer)
 {
     base.Deserialize(so, deserializer);
     this.label = deserializer.DeserializeStringMemberVariable(so, "label");
     this.propertyName = deserializer.DeserializeStringMemberVariable(so, "propertyName");
     this.formatPropertyField = (FormatPropertyField) deserializer.DeserializeMandatoryMemberObject(so, "formatPropertyField");
 }
Esempio n. 22
0
        public ExecutableNodeFactory(Executable executable,Executables collection)
        {
            _collection = collection;
            _executable = (DtsContainer)executable;
            _host = _executable as TaskHost;
            _seq = _executable as Sequence;
            _foreachloop = _executable as ForEachLoop;
            _forloop = _executable as ForLoop;
            _psExecutable = PSObject.AsPSObject(_executable);

            if (null != _host)
            {
                _psExecutable.Properties.Add( new PSNoteProperty( "IsTaskHost", true ));
                _mainPipe = _host.InnerObject as MainPipe;
            }
            if (null != _mainPipe)
            {
                _psExecutable.Properties.Add(new PSNoteProperty("IsDataFlow", true));
            }
            if (null != _seq)
            {
                _psExecutable.Properties.Add(new PSNoteProperty("IsSequence", true));
            }
            if (null != _foreachloop)
            {
                _psExecutable.Properties.Add(new PSNoteProperty("IsForEachLoop", true));
            }
            if (null != _forloop)
            {
                _psExecutable.Properties.Add(new PSNoteProperty("IsForLoop", true));
            }
        }
Esempio n. 23
0
 private PSObject BuildHostLevelPSObjectArrayList(object objSessionObject, string uri, bool IsWsManLevel)
 {
     PSObject obj2 = new PSObject();
     if (IsWsManLevel)
     {
         foreach (string str in WSManHelper.GetSessionObjCache().Keys)
         {
             obj2.Properties.Add(new PSNoteProperty(str, "Container"));
         }
         return obj2;
     }
     if (objSessionObject != null)
     {
         foreach (XmlNode node in this.GetResourceValue(objSessionObject, uri, null).ChildNodes)
         {
             foreach (XmlNode node2 in node.ChildNodes)
             {
                 if ((node2.ChildNodes.Count == 0) || node2.FirstChild.Name.Equals("#text", StringComparison.OrdinalIgnoreCase))
                 {
                     obj2.Properties.Add(new PSNoteProperty(node2.LocalName, node2.InnerText));
                 }
             }
         }
     }
     foreach (string str2 in WinRmRootConfigs)
     {
         obj2.Properties.Add(new PSNoteProperty(str2, "Container"));
     }
     return obj2;
 }
        private Object ConvertToReturnObject(object currentObject)
        {
            List<Object> currentAsArray = currentObject as List<Object>;
            if(currentAsArray != null)
            {
                PSObject[] result = new PSObject[currentAsArray.Count];

                for(int currentIndex = 0; currentIndex < currentAsArray.Count; currentIndex++)
                {
                    result[currentIndex] = (PSObject) ConvertToReturnObject(currentAsArray[currentIndex]);
                }

                return result;
            }

            OrderedDictionary currentAsDictionary = currentObject as OrderedDictionary;
            if (currentAsDictionary != null)
            {
                PSObject result = new PSObject();
                foreach (string key in currentAsDictionary.Keys)
                {
                    result.Properties.Add(new PSNoteProperty(key, ConvertToReturnObject(currentAsDictionary[key])));
                }

                return result;
            }

            return currentObject;
        }
Esempio n. 25
0
        int Compare(PSObject x, PSObject y)
        {
            if (Descending.ToBool())
            {
                var temp = x;
                x = y;
                y = temp;
            }

            if (this.Property == null)
            {
                return LanguagePrimitives.Compare(x, y);
            }

            foreach (var property in this.Property)
            {
                var xPropertyValue = x.BaseObject.GetType().GetProperty(property.ToString(), BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase).GetValue(x.BaseObject, null);
                var yPropertyValue = y.BaseObject.GetType().GetProperty(property.ToString(), BindingFlags.Public | BindingFlags.Instance | BindingFlags.IgnoreCase).GetValue(y.BaseObject, null);

                var result = LanguagePrimitives.Compare(xPropertyValue, yPropertyValue);
                if (result != 0) return result;
            }

            return 0;
        }
        /// <summary>
        /// A function which returns a Stream object which encapsulates an IStream interface
        /// This makes it much easier to get the file contents in managed code / powershell
        /// </summary>
        /// <param name="parentObject">This will be the PSObject that encapsulates a IFsrmPropertyBag</param>
        /// <returns>A stream which wraps the parentObject's IStream</returns>
        public static StreamWrapperForIStream GetStream(PSObject parentObject)
        {
            IFsrmPropertyBag propertyBag = (IFsrmPropertyBag)parentObject.BaseObject;

            IStream istream = (IStream)propertyBag.GetFileStreamInterface(_FsrmFileStreamingMode.FsrmFileStreamingMode_Read, _FsrmFileStreamingInterfaceType.FsrmFileStreamingInterfaceType_IStream );
            return new StreamWrapperForIStream(istream);
        }
Esempio n. 27
0
 public void ConvertToCanPackAsPSObjectArray()
 {
     var result = LanguagePrimitives.ConvertTo(3, typeof(PSObject[]));
     var expected = new PSObject[] { PSObject.AsPSObject(3) };
     Assert.AreEqual(expected.GetType(), result.GetType());
     Assert.AreEqual(expected, result);
 }
        /// <summary>
        /// Converts a <see cref="JObject"/> to a <see cref="PSObject"/>
        /// </summary>
        /// <param name="jtoken">The <see cref="JObject"/></param>
        /// <param name="objectFormat">The <see cref="ResourceObjectFormat"/></param>
        /// <param name="objectType">The type of the object.</param>
        internal static PSObject ToPsObject(this JToken jtoken, ResourceObjectFormat objectFormat, string objectType = null)
        {
            if (jtoken == null)
            {
                return null;
            }

            if (jtoken.Type != JTokenType.Object)
            {
                return new PSObject(JTokenExtensions.ConvertPropertyValueForPsObject(propertyValue: jtoken, objectFormat: objectFormat));
            }

            var jobject = (JObject)jtoken;
            var psObject = new PSObject();

            if (jobject.CanConvertTo<Resource<JToken>>())
            {
                return jobject.ToResource().ToPsObject(objectFormat);
            }

            if (!string.IsNullOrWhiteSpace(objectType))
            {
                psObject.TypeNames.Add(objectType);
            }

            foreach (var property in jobject.Properties())
            {
                psObject.Properties.Add(new PSNoteProperty(
                    name: JTokenExtensions.ConvertToPascalCase(propertyName: property.Name), 
                    value: JTokenExtensions.ConvertPropertyValueForPsObject(propertyValue: property.Value, objectFormat: objectFormat)));
            }

            return psObject;
        }
Esempio n. 29
0
 private void AddProperties(PSObject psobj)
 {
     foreach (var keyObj in Property.Keys)
     {
         var key = keyObj.ToString(); // should be a string anyway
         var member = psobj.Members[key];
         if (member == null)
         {
             if (psobj.BaseObject is PSCustomObject)
             {
                 var noteProperty = new PSNoteProperty(key, Property[key]);
                 AddMemberToCollection(psobj.Properties, noteProperty, false);
                 AddMemberToCollection(psobj.Members, noteProperty, false);
             }
             else
             {
                 var msg = String.Format("A member with the name {0} doesn't exist", key);
                 WriteError(new PSInvalidOperationException(msg).ErrorRecord);
             }
         }
         else if (member is PSMethodInfo)
         {
             var method = member as PSMethodInfo;
             method.Invoke(Property[key]);
         }
         else if (member is PSPropertyInfo)
         {
             var psproperty = member as PSPropertyInfo;
             psproperty.Value = Property[key];
         }
     }
 }
Esempio n. 30
0
        /// <summary>
        /// Let the view prepare itself for RemoteObjects. This will add "ComputerName" to the 
        /// table columns.
        /// </summary>
        /// <param name="so"></param>
        internal override void PrepareForRemoteObjects(PSObject so)
        {
            Diagnostics.Assert(null != so, "so cannot be null");

            // make sure computername property exists.
            Diagnostics.Assert(null != so.Properties[RemotingConstants.ComputerNameNoteProperty],
                "PrepareForRemoteObjects cannot be called when the object does not contain ComputerName property.");

            if ((dataBaseInfo != null) && (dataBaseInfo.view != null) && (dataBaseInfo.view.mainControl != null))
            {
                // dont change the original format definition in the database..just make a copy and work
                // with the copy
                _tableBody = (TableControlBody)this.dataBaseInfo.view.mainControl.Copy();

                TableRowItemDefinition cnRowDefinition = new TableRowItemDefinition();
                PropertyTokenBase propToken = new FieldPropertyToken();
                propToken.expression = new ExpressionToken(RemotingConstants.ComputerNameNoteProperty, false);
                cnRowDefinition.formatTokenList.Add(propToken);
                _tableBody.defaultDefinition.rowItemDefinitionList.Add(cnRowDefinition);

                // add header only if there are other header definitions
                if (_tableBody.header.columnHeaderDefinitionList.Count > 0)
                {
                    TableColumnHeaderDefinition cnHeaderDefinition = new TableColumnHeaderDefinition();
                    cnHeaderDefinition.label = new TextToken();
                    cnHeaderDefinition.label.text = RemotingConstants.ComputerNameNoteProperty;
                    _tableBody.header.columnHeaderDefinitionList.Add(cnHeaderDefinition);
                }
            }
        }
Esempio n. 31
0
        /// <summary>
        /// This is implementation for Get cmdlet: all instances, single instance, Get on associations
        /// </summary>
        /// <param name="query"></param>
        public override void ProcessRecord(QueryBuilder query)
        {
            ODataQueryBuilder odataQuery = query as ODataQueryBuilder;

            if (!this.PassInnerException.IsPresent)
            {
                string passInnerExceptionKey = "PassInnerException";
                if (PrivateData.ContainsKey(passInnerExceptionKey))
                {
                    string PassInnerExceptionValue = PrivateData[passInnerExceptionKey];
                    this.PassInnerException = PassInnerExceptionValue.Equals("True", StringComparison.OrdinalIgnoreCase);
                }
            }

            string parentTypeName       = this.Cmdlet.ParameterSetName;
            string privateDataEntryName = "NavigationLink" + parentTypeName;

            if (PrivateData.ContainsKey(privateDataEntryName))
            {
                string parent = PrivateData[privateDataEntryName];

                string[] parentParts        = parent.Split('|');
                string   parentPropertyName = parentParts[2];

                System.Management.Automation.PSObject[] argumentObjects = (System.Management.Automation.PSObject[]) this.Cmdlet.MyInvocation.BoundParameters[parentTypeName];

                foreach (System.Management.Automation.PSObject parentObject in argumentObjects)
                {
                    bool isCollection = parentParts[parentParts.Length - 1].Equals("Collection", StringComparison.OrdinalIgnoreCase);

                    if (isCollection)
                    {
                        object[] parentPropertyObjectArray = (object[])parentObject.Properties[parentPropertyName].Value;
                        foreach (System.Management.Automation.PSObject parentPropertyObject in parentPropertyObjectArray)
                        {
                            string     odataId    = (string)parentPropertyObject.Properties["@odata.id"].Value;
                            string     hostUri    = GetCustomUriHelper(this.ClassName, this.ConnectionUri, odataQuery.Keys);
                            UriBuilder uriBuilder = new UriBuilder(hostUri);
                            uriBuilder.Path = odataId;
                            GetCmdlet(this.Cmdlet, uriBuilder.Uri, true, odataQuery);
                        }
                    }
                    else
                    {
                        System.Management.Automation.PSObject parentPropertyObject = (System.Management.Automation.PSObject)parentObject.Properties[parentPropertyName].Value;
                        string     odataId    = (string)parentPropertyObject.Properties["@odata.id"].Value;
                        string     hostUri    = GetCustomUriHelper(this.ClassName, this.ConnectionUri, odataQuery.Keys);
                        UriBuilder uriBuilder = new UriBuilder(hostUri);
                        uriBuilder.Path = odataId;
                        GetCmdlet(this.Cmdlet, uriBuilder.Uri, true, odataQuery);
                    }
                }
            }
            else
            {
                base.ProcessRecord(query);
            }
        }
Esempio n. 32
0
        protected override Uri BuildODataUri(string uri, Dictionary <string, string> queryParameters)
        {
            System.Management.Automation.PSObject argumentObjects      = (System.Management.Automation.PSObject) this.Cmdlet.MyInvocation.BoundParameters["Value"];
            System.Management.Automation.PSObject parentPropertyObject = argumentObjects;

            string     odataId    = (string)parentPropertyObject.Properties["@odata.id"].Value;
            string     hostUri    = GetCustomUriHelper(this.ClassName, this.ConnectionUri, null);
            UriBuilder uriBuilder = new UriBuilder(hostUri);

            uriBuilder.Path = odataId;

            return(uriBuilder.Uri);
        }
Esempio n. 33
0
        private bool HandleParseError(SMA.PSObject result, string describe)
        {
            string value = string.Format("Error in {0}", File);

            if (describe.Contains(value))
            {
                string errorStackTrace = result.Properties["StackTrace"].Value as string;
                string errorMessage    = result.Properties["FailureMessage"].Value as string;

                foreach (TestCase testCase in TestCases)
                {
                    TestResult testResult = new TestResult(testCase);
                    testResult.Outcome         = TestOutcome.Failed;
                    testResult.ErrorMessage    = errorMessage;
                    testResult.ErrorStackTrace = errorStackTrace;
                    TestResults.Add(testResult);
                }

                return(false);
            }
            return(true);
        }
Esempio n. 34
0
            public override Dictionary <string, PSObject> Prompt(string caption, string message, System.Collections.ObjectModel.Collection <FieldDescription> descriptions)
            {
                this.Write(caption + "\n" + message + " ");
                Dictionary <string, PSObject> results = new Dictionary <string, PSObject>();

                foreach (FieldDescription fd in descriptions)
                {
                    string[] label = GetHotkeyAndLabel(fd.Label);
                    this.WriteLine(label[1]);

                    string data = this.ReadLine();

                    if (data == null)
                    {
                        return(null);
                    }

                    results[fd.Name] = PSObject.AsPSObject(data);
                }

                return(results);
            }
Esempio n. 35
0
        public void ProcessTestResults(Array results)
        {
            TestResults = new List <TestResult>();

            foreach (object obj in results)
            {
                SMA.PSObject psobject = (SMA.PSObject)obj;
                string       describe = psobject.Properties["Describe"].Value as string;

                if (!HandleParseError(psobject, describe))
                {
                    break;
                }

                string context = psobject.Properties["Context"].Value as string;
                string name    = psobject.Properties["Name"].Value as string;

                if (string.IsNullOrEmpty(context))
                {
                    context = "No Context";
                }

                TestCase testCase = TestCases.FirstOrDefault(m => m.FullyQualifiedName == $"{describe}.{context}.{name}");

                if (testCase != null)
                {
                    TestResult testResult = new TestResult(testCase);
                    testResult.Outcome = GetOutcome(psobject.Properties["Result"].Value as string);
                    string errorStackTrace = psobject.Properties["StackTrace"].Value as string;
                    string errorMessage    = psobject.Properties["FailureMessage"].Value as string;
                    testResult.ErrorStackTrace = errorStackTrace;
                    testResult.ErrorMessage    = errorMessage;

                    TestResults.Add(testResult);
                }
            }
        }
Esempio n. 36
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="record"></param>
 public DebugRecord(PSObject record)
     : base(record)
 {
 }
Esempio n. 37
0
        /// <summary>
        /// Convert an listItem node into an PSObject with property "tag" and "text"
        /// </summary>
        /// <param name="xmlNode"></param>
        /// <param name="ordered"></param>
        /// <param name="index"></param>
        /// <returns></returns>
        private PSObject GetListItemPSObject(XmlNode xmlNode, bool ordered, ref int index)
        {
            if (xmlNode == null)
            {
                return(null);
            }

            if (!xmlNode.LocalName.Equals("listItem", StringComparison.OrdinalIgnoreCase))
            {
                return(null);
            }

            string text = string.Empty;

            if (xmlNode.ChildNodes.Count > 1)
            {
                WriteMamlInvalidChildNodeCountError(xmlNode, "para", 1);
            }

            foreach (XmlNode childNode in xmlNode.ChildNodes)
            {
                if (childNode.LocalName.Equals("para", StringComparison.OrdinalIgnoreCase))
                {
                    text = childNode.InnerText.Trim();
                    continue;
                }

                WriteMamlInvalidChildNodeError(xmlNode, childNode);
            }

            string tag = string.Empty;

            if (ordered)
            {
                tag  = index.ToString("d2", CultureInfo.CurrentCulture);
                tag += ". ";
                index++;
            }
            else
            {
                tag = "* ";
            }

            PSObject mshObject = new PSObject();

            mshObject.Properties.Add(new PSNoteProperty("Text", text));
            mshObject.Properties.Add(new PSNoteProperty("Tag", tag));

            mshObject.TypeNames.Clear();
            if (ordered)
            {
                mshObject.TypeNames.Add("MamlOrderedListTextItem");
            }
            else
            {
                mshObject.TypeNames.Add("MamlUnorderedListTextItem");
            }

            mshObject.TypeNames.Add("MamlTextItem");

            return(mshObject);
        }
Esempio n. 38
0
        /// <summary>
        /// Get a Hashtable object out of a PowerShell data file (.psd1)
        /// </summary>
        /// <param name="parameterName">
        /// Name of the parameter that takes the specified .psd1 file as a value
        /// </param>
        /// <param name="psDataFilePath">
        /// Path to the powershell data file
        /// </param>
        /// <param name="context">
        /// ExecutionContext to use
        /// </param>
        /// <param name="allowedCommands">
        /// Set of command names that are allowed to use in the .psd1 file
        /// </param>
        /// <param name="allowedVariables">
        /// Set of variable names that are allowed to use in the .psd1 file
        /// </param>
        /// <param name="allowEnvironmentVariables">
        /// If true, allow to use environment variables in the .psd1 file
        /// </param>
        /// <param name="skipPathValidation">
        /// If true, caller guarantees the path is valid
        /// </param>
        /// <returns></returns>
        internal static Hashtable EvaluatePowerShellDataFile(
            string parameterName,
            string psDataFilePath,
            ExecutionContext context,
            IEnumerable <string> allowedCommands,
            IEnumerable <string> allowedVariables,
            bool allowEnvironmentVariables,
            bool skipPathValidation)
        {
            if (!skipPathValidation && string.IsNullOrEmpty(parameterName))
            {
                throw PSTraceSource.NewArgumentNullException("parameterName");
            }

            if (string.IsNullOrEmpty(psDataFilePath))
            {
                throw PSTraceSource.NewArgumentNullException("psDataFilePath");
            }

            if (context == null)
            {
                throw PSTraceSource.NewArgumentNullException("context");
            }

            string resolvedPath;

            if (skipPathValidation)
            {
                resolvedPath = psDataFilePath;
            }
            else
            {
                #region "ValidatePowerShellDataFilePath"

                bool isPathValid = true;

                // File extension needs to be .psd1
                string pathExt = Path.GetExtension(psDataFilePath);
                if (string.IsNullOrEmpty(pathExt) ||
                    !StringLiterals.PowerShellDataFileExtension.Equals(pathExt, StringComparison.OrdinalIgnoreCase))
                {
                    isPathValid = false;
                }

                ProviderInfo provider;
                var          resolvedPaths = context.SessionState.Path.GetResolvedProviderPathFromPSPath(psDataFilePath, out provider);

                // ConfigPath should be resolved as FileSystem provider
                if (provider == null || !Microsoft.PowerShell.Commands.FileSystemProvider.ProviderName.Equals(provider.Name, StringComparison.OrdinalIgnoreCase))
                {
                    isPathValid = false;
                }

                // ConfigPath should be resolved to a single path
                if (resolvedPaths.Count != 1)
                {
                    isPathValid = false;
                }

                if (!isPathValid)
                {
                    throw PSTraceSource.NewArgumentException(
                              parameterName,
                              ParserStrings.CannotResolvePowerShellDataFilePath,
                              psDataFilePath);
                }

                resolvedPath = resolvedPaths[0];

                #endregion "ValidatePowerShellDataFilePath"
            }

            #region "LoadAndEvaluatePowerShellDataFile"

            object evaluationResult;
            try
            {
                // Create the scriptInfo for the .psd1 file
                string      dataFileName       = Path.GetFileName(resolvedPath);
                var         dataFileScriptInfo = new ExternalScriptInfo(dataFileName, resolvedPath, context);
                ScriptBlock scriptBlock        = dataFileScriptInfo.ScriptBlock;

                // Validate the scriptblock
                scriptBlock.CheckRestrictedLanguage(allowedCommands, allowedVariables, allowEnvironmentVariables);

                // Evaluate the scriptblock
                object oldPsScriptRoot = context.GetVariableValue(SpecialVariables.PSScriptRootVarPath);
                try
                {
                    // Set the $PSScriptRoot before the evaluation
                    context.SetVariable(SpecialVariables.PSScriptRootVarPath, Path.GetDirectoryName(resolvedPath));
                    evaluationResult = PSObject.Base(scriptBlock.InvokeReturnAsIs());
                }
                finally
                {
                    context.SetVariable(SpecialVariables.PSScriptRootVarPath, oldPsScriptRoot);
                }
            }
            catch (RuntimeException ex)
            {
                throw PSTraceSource.NewInvalidOperationException(
                          ex,
                          ParserStrings.CannotLoadPowerShellDataFile,
                          psDataFilePath,
                          ex.Message);
            }

            var retResult = evaluationResult as Hashtable;
            if (retResult == null)
            {
                throw PSTraceSource.NewInvalidOperationException(
                          ParserStrings.InvalidPowerShellDataFile,
                          psDataFilePath);
            }

            #endregion "LoadAndEvaluatePowerShellDataFile"

            return(retResult);
        }
Esempio n. 39
0
 /// <summary>
 /// Initializes a new instance of the <see cref="PSObjectTypeDescriptor"/> that provides
 /// property information about <paramref name="instance"/>.
 /// </summary>
 /// <param name="instance">The <see cref="PSObject"/> this class retrieves property information from.</param>
 public PSObjectTypeDescriptor(PSObject instance)
 {
     Instance = instance;
 }
Esempio n. 40
0
 public PSEventHandler(PSEventManager eventManager, object sender, string sourceIdentifier, PSObject extraData)
 {
     this.eventManager     = eventManager;
     this.sender           = sender;
     this.sourceIdentifier = sourceIdentifier;
     this.extraData        = extraData;
 }
Esempio n. 41
0
        /// <summary>
        /// Binds the specified parameters to the native command.
        /// </summary>
        /// <param name="parameters">
        /// The parameters to bind.
        /// </param>
        /// <param name="outputRedirected">
        /// true if minishell output is redirected.
        /// </param>
        /// <param name="hostName">
        /// name of the calling host.
        /// </param>
        /// <remarks>
        /// For any parameters that do not have a name, they are added to the command
        /// line arguments for the command
        /// </remarks>
        internal Collection <CommandParameterInternal> BindParameters(Collection <CommandParameterInternal> parameters, bool outputRedirected, string hostName)
        {
            MinishellParameters seen = 0;
            string inputFormat       = null;
            string outputFormat      = null;

            for (int i = 0; i < parameters.Count; i++)
            {
                var parameter = parameters[i];

                if (parameter.ParameterNameSpecified)
                {
                    var parameterName = parameter.ParameterName;

                    if (CommandParameter.StartsWith(parameterName, StringComparison.OrdinalIgnoreCase))
                    {
                        HandleSeenParameter(ref seen, MinishellParameters.Command, CommandParameter);

                        // Value must be specified for -Command parameter.
                        if (i + 1 >= parameters.Count)
                        {
                            throw NewParameterBindingException(null, ErrorCategory.InvalidArgument, CommandParameter,
                                                               typeof(ScriptBlock), null,
                                                               NativeCP.NoValueForCommandParameter,
                                                               "NoValueForCommandParameter");
                        }

                        i += 1;

                        // Value of -Command parameter must be scriptblock
                        var scriptBlockArgument = parameters[i];
                        var argumentValue       = PSObject.Base(scriptBlockArgument.ArgumentValue);
                        if (!scriptBlockArgument.ArgumentSpecified || !(argumentValue is ScriptBlock))
                        {
                            throw NewParameterBindingException(null, ErrorCategory.InvalidArgument, CommandParameter,
                                                               typeof(ScriptBlock), argumentValue.GetType(),
                                                               NativeCP.IncorrectValueForCommandParameter,
                                                               "IncorrectValueForCommandParameter");
                        }

                        // Replace the parameters with -EncodedCommand <base64 encoded scriptblock>
                        parameters[i - 1] = CommandParameterInternal.CreateParameter(EncodedCommandParameter, "-" + EncodedCommandParameter, parameter.ParameterAst);
                        string encodedScript = StringToBase64Converter.StringToBase64String(argumentValue.ToString());
                        parameters[i] = CommandParameterInternal.CreateArgument(encodedScript, scriptBlockArgument.ArgumentAst);
                    }
                    else if (InputFormatParameter.StartsWith(parameterName, StringComparison.OrdinalIgnoreCase))
                    {
                        HandleSeenParameter(ref seen, MinishellParameters.InputFormat, InputFormatParameter);

                        // Value for -Inputformat must be specified
                        if (i + 1 >= parameters.Count)
                        {
                            throw NewParameterBindingException(null, ErrorCategory.InvalidArgument, InputFormatParameter,
                                                               typeof(string), null,
                                                               NativeCP.NoValueForInputFormatParameter,
                                                               "NoValueForInputFormatParameter");
                        }

                        // Update the argument (partial arguments are allowed)
                        i += 1;
                        var inputFormatArg = parameters[i];
                        inputFormat       = ProcessFormatParameterValue(InputFormatParameter, inputFormatArg.ArgumentValue);
                        parameters[i - 1] = CommandParameterInternal.CreateParameter(InputFormatParameter, "-" + InputFormatParameter, parameter.ParameterAst);
                        parameters[i]     = CommandParameterInternal.CreateArgument(inputFormat, inputFormatArg.ArgumentAst);
                    }
                    else if (OutputFormatParameter.StartsWith(parameterName, StringComparison.OrdinalIgnoreCase))
                    {
                        HandleSeenParameter(ref seen, MinishellParameters.OutputFormat, OutputFormatParameter);

                        // Value for -Inputformat must be specified
                        if (i + 1 >= parameters.Count)
                        {
                            throw NewParameterBindingException(null, ErrorCategory.InvalidArgument, OutputFormatParameter,
                                                               typeof(string), null,
                                                               NativeCP.NoValueForOutputFormatParameter,
                                                               "NoValueForInputFormatParameter");
                        }

                        // Update the argument (partial arguments are allowed)
                        i += 1;
                        var outputFormatArg = parameters[i];
                        outputFormat      = ProcessFormatParameterValue(OutputFormatParameter, outputFormatArg.ArgumentValue);
                        parameters[i - 1] = CommandParameterInternal.CreateParameter(OutputFormatParameter, "-" + OutputFormatParameter, parameter.ParameterAst);
                        parameters[i]     = CommandParameterInternal.CreateArgument(outputFormat, outputFormatArg.ArgumentAst);
                    }
                    else if (ArgsParameter.StartsWith(parameterName, StringComparison.OrdinalIgnoreCase))
                    {
                        HandleSeenParameter(ref seen, MinishellParameters.Arguments, ArgsParameter);

                        // Value for -Args parameter must be specified
                        if (i + 1 >= parameters.Count)
                        {
                            throw NewParameterBindingException(null, ErrorCategory.InvalidArgument, ArgsParameter,
                                                               typeof(string), null, NativeCP.NoValuesSpecifiedForArgs,
                                                               "NoValuesSpecifiedForArgs");
                        }

                        // Get the encoded value for -args parameter
                        i += 1;
                        var argsArg     = parameters[i];
                        var encodedArgs = ConvertArgsValueToEncodedString(argsArg.ArgumentValue);
                        parameters[i - 1] = CommandParameterInternal.CreateParameter(EncodedArgsParameter, "-" + EncodedArgsParameter, parameter.ParameterAst);
                        // NOTE: do not pass the ArgumentAst; it will fail validation in BindParameters if there
                        // are multiple arguments (array) but encodedArgs is an encoded string.
                        parameters[i] = CommandParameterInternal.CreateArgument(encodedArgs);
                    }
                }
                else
                {
                    // -Command is positional parameter. Bind first scriptblock to it, others are errors.
                    var scriptBlockArgument = parameters[i];
                    var argumentValue       = PSObject.Base(scriptBlockArgument.ArgumentValue);
                    if (argumentValue is ScriptBlock)
                    {
                        HandleSeenParameter(ref seen, MinishellParameters.Command, CommandParameter);

                        // Replace the argument with -EncodedCommand <base64 encoded scriptblock>
                        string encodedScript = StringToBase64Converter.StringToBase64String(argumentValue.ToString());
                        parameters[i] = CommandParameterInternal.CreateParameterWithArgument(
                            parameter.ArgumentAst, EncodedCommandParameter, "-" + EncodedCommandParameter,
                            parameter.ArgumentAst, encodedScript,
                            spaceAfterParameter: true);
                    }
                }
            }

            // Add InputFormat and OutputFormat parameter if not specified
            if (inputFormat == null)
            {
                // For minishell default input format is xml
                parameters.Add(CommandParameterInternal.CreateParameter(InputFormatParameter, "-" + InputFormatParameter));
                parameters.Add(CommandParameterInternal.CreateArgument(XmlFormatValue));
                inputFormat = XmlFormatValue;
            }

            if (outputFormat == null)
            {
                // If output is redirected, output format should be xml
                outputFormat = outputRedirected ? XmlFormatValue : TextFormatValue;
                parameters.Add(CommandParameterInternal.CreateParameter(OutputFormatParameter, "-" + OutputFormatParameter));
                parameters.Add(CommandParameterInternal.CreateArgument(outputFormat));
            }

            // Set the output and input format class variable
            InputFormat = XmlFormatValue.StartsWith(inputFormat, StringComparison.OrdinalIgnoreCase)
                ? NativeCommandIOFormat.Xml
                : NativeCommandIOFormat.Text;
            OutputFormat = XmlFormatValue.StartsWith(outputFormat, StringComparison.OrdinalIgnoreCase)
                ? NativeCommandIOFormat.Xml
                : NativeCommandIOFormat.Text;

            // Note if a minishell is invoked from a non-console host, we need to
            // pass -nonInteractive flag. Our console host's name is "ConsoleHost".
            // Correct check would be see if current host has access to console and
            // pass noninteractive flag if doesn't.
            if (string.IsNullOrEmpty(hostName) || !hostName.Equals("ConsoleHost", StringComparison.OrdinalIgnoreCase))
            {
                NonInteractive = true;
                parameters.Insert(0, CommandParameterInternal.CreateParameter(NonInteractiveParameter, "-" + NonInteractiveParameter));
            }

            ((NativeCommandParameterBinder)DefaultParameterBinder).BindParameters(parameters);

            Diagnostics.Assert(s_emptyReturnCollection.Count == 0, "This list shouldn't be used for anything as it's shared.");

            return(s_emptyReturnCollection);
        }
Esempio n. 42
0
 /// <summary>
 /// Reads the information the PSObject
 /// and returns true if this object should be serialized as string.
 /// </summary>
 /// <param name="source">PSObject to be serialized.</param>
 /// <returns>True if the object needs to be serialized as a string.</returns>
 private static bool SerializeAsString(PSObject source)
 {
     return(source.GetSerializationMethod(null) == SerializationMethod.String);
 }
Esempio n. 43
0
        private bool HandleKnownContainerTypes(object source, string property, int depth)
        {
            Dbg.Assert(source != null, "caller should validate the parameter");

            ContainerType ct         = ContainerType.None;
            PSObject      mshSource  = source as PSObject;
            IEnumerable   enumerable = null;
            IDictionary   dictionary = null;

            // If passed in object is PSObject with no baseobject, return false.
            if (mshSource != null && mshSource.ImmediateBaseObjectIsEmpty)
            {
                return(false);
            }

            // Check if source (or baseobject in mshSource) is known container type
            GetKnownContainerTypeInfo(mshSource != null ? mshSource.ImmediateBaseObject : source, out ct,
                                      out dictionary, out enumerable);

            if (ct == ContainerType.None)
            {
                return(false);
            }

            WriteStartOfPSObject(mshSource ?? PSObject.AsPSObject(source), property, true);
            switch (ct)
            {
            case ContainerType.Dictionary:
            {
                WriteDictionary(dictionary, depth);
            }

            break;

            case ContainerType.Stack:
            case ContainerType.Queue:
            case ContainerType.List:
            case ContainerType.Enumerable:
            {
                WriteEnumerable(enumerable, depth);
            }

            break;

            default:
            {
                Dbg.Assert(false, "All containers should be handled in the switch");
            }

            break;
            }

            // An object which is original enumerable becomes an PSObject
            // with arraylist on deserialization. So on roundtrip it will show up
            // as List.
            // We serialize properties of enumerable and on deserialization mark the object
            // as Deserialized. So if object is marked deserialized, we should write properties.
            // Note: we do not serialize the properties of IEnumerable if depth is zero.
            if (depth != 0 && (ct == ContainerType.Enumerable || (mshSource != null && mshSource.IsDeserialized)))
            {
                // Note:Depth is the depth for serialization of baseObject.
                // Depth for serialization of each property is one less.
                WritePSObjectProperties(PSObject.AsPSObject(source), depth);
            }

            // If source is PSObject, serialize notes
            if (mshSource != null)
            {
                // Serialize instanceMembers
                PSMemberInfoCollection <PSMemberInfo> instanceMembers = mshSource.InstanceMembers;
                if (instanceMembers != null)
                {
                    WriteMemberInfoCollection(instanceMembers, depth, true);
                }
            }

            _writer.WriteEndElement();

            return(true);
        }
Esempio n. 44
0
        /// <summary>
        /// Creates an InformationalRecord from an instance serialized as a PSObject by ToPSObjectForRemoting.
        /// </summary>
        internal InvocationInfo(PSObject psObject)
        {
            CommandOrigin    = (CommandOrigin)SerializationUtilities.GetPsObjectPropertyBaseObject(psObject, "InvocationInfo_CommandOrigin");
            ExpectingInput   = (bool)SerializationUtilities.GetPropertyValue(psObject, "InvocationInfo_ExpectingInput");
            _invocationName  = (string)SerializationUtilities.GetPropertyValue(psObject, "InvocationInfo_InvocationName");
            HistoryId        = (long)SerializationUtilities.GetPropertyValue(psObject, "InvocationInfo_HistoryId");
            PipelineLength   = (int)SerializationUtilities.GetPropertyValue(psObject, "InvocationInfo_PipelineLength");
            PipelinePosition = (int)SerializationUtilities.GetPropertyValue(psObject, "InvocationInfo_PipelinePosition");

            string scriptName       = (string)SerializationUtilities.GetPropertyValue(psObject, "InvocationInfo_ScriptName");
            int    scriptLineNumber = (int)SerializationUtilities.GetPropertyValue(psObject, "InvocationInfo_ScriptLineNumber");
            int    offsetInLine     = (int)SerializationUtilities.GetPropertyValue(psObject, "InvocationInfo_OffsetInLine");
            string line             = (string)SerializationUtilities.GetPropertyValue(psObject, "InvocationInfo_Line");
            var    scriptPosition   = new ScriptPosition(scriptName, scriptLineNumber, offsetInLine, line);

            ScriptPosition scriptEndPosition;

            if (!string.IsNullOrEmpty(line))
            {
                int endColumn = line.Length + 1;
                scriptEndPosition = new ScriptPosition(scriptName, scriptLineNumber, endColumn, line);
            }
            else
            {
                scriptEndPosition = scriptPosition;
            }

            _scriptPosition = new ScriptExtent(scriptPosition, scriptEndPosition);

            MyCommand = RemoteCommandInfo.FromPSObjectForRemoting(psObject);

            //
            // Arrays are de-serialized as ArrayList so we need to convert the deserialized
            // object into an int[] before assigning to pipelineIterationInfo.
            //
            var list = (ArrayList)SerializationUtilities.GetPsObjectPropertyBaseObject(psObject, "InvocationInfo_PipelineIterationInfo");

            if (list != null)
            {
                PipelineIterationInfo = (int[])list.ToArray(typeof(int));
            }
            else
            {
                PipelineIterationInfo = Array.Empty <int>();
            }

            //
            // Dictionaries are de-serialized as Hashtables so we need to convert the deserialized object into a dictionary
            // before assigning to CommandLineParameters.
            //
            Hashtable hashtable = (Hashtable)SerializationUtilities.GetPsObjectPropertyBaseObject(psObject, "InvocationInfo_BoundParameters");

            Dictionary <string, object> dictionary = new Dictionary <string, object>();

            if (hashtable != null)
            {
                foreach (DictionaryEntry entry in hashtable)
                {
                    dictionary.Add((string)entry.Key, entry.Value);
                }
            }

            _boundParameters = dictionary;

            //
            // The unbound parameters are de-serialized as an ArrayList, which we need to convert to a List
            //
            var unboundArguments = (ArrayList)SerializationUtilities.GetPsObjectPropertyBaseObject(psObject, "InvocationInfo_UnboundArguments");

            _unboundArguments = new List <object>();

            if (unboundArguments != null)
            {
                foreach (object o in unboundArguments)
                {
                    _unboundArguments.Add(o);
                }
            }

            object value           = SerializationUtilities.GetPropertyValue(psObject, "SerializeExtent");
            bool   serializeExtent = false;

            if (value != null)
            {
                serializeExtent = (bool)value;
            }

            if (serializeExtent)
            {
                DisplayScriptPosition = ScriptExtent.FromPSObjectForRemoting(psObject);
            }
        }
 /// <summary>
 /// Send the output data to the client
 /// </summary>
 /// <param name="data">data to send</param>
 internal void SendOutputDataToClient(PSObject data)
 {
     SendDataAsync(RemotingEncoder.GeneratePowerShellOutput(data,
                                                            _clientPowerShellId, _clientRunspacePoolId));
 }
Esempio n. 46
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="record"></param>
 public WarningRecord(PSObject record)
     : base(record)
 {
 }
Esempio n. 47
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="record"></param>
 public VerboseRecord(PSObject record)
     : base(record)
 {
 }
Esempio n. 48
0
 public static Collection <string> PSTypeNames(PSObject o)
 {
     return(o.TypeNames);
 }
Esempio n. 49
0
 /// <summary>
 /// Constructor for Fully qualified warning Id.
 /// </summary>
 /// <param name="fullyQualifiedWarningId">Fully qualified warning Id</param>
 /// <param name="record">Warning serialized object</param>
 public WarningRecord(string fullyQualifiedWarningId, PSObject record)
     : base(record)
 {
     _fullyQualifiedWarningId = fullyQualifiedWarningId;
 }