public override object Transform(EngineIntrinsics engineIntrinsics, object inputData)
        {
            if (null == inputData )
            {
                return null;
            }

            var typeName = inputData.ToString();
            var re = new Regex(@"^\[[\w\.]+\]$");

            if (!re.IsMatch( typeName ))
            {
                return inputData;
            }

            var results = engineIntrinsics.InvokeCommand.InvokeScript(typeName);
            if (! results.Any())
            {
                return null;
            }

            var type = results.First().BaseObject as Type;
            if (null == type)
            {
                throw new ArgumentException( String.Format(
                    "The string specified '{0}' could not be interpreted as a valid type name.  Please ensure you have loaded the assembly containing the type into your PowerShell session prior to calling this command.",
                    inputData
                                                 )
                    );
            }

            return type;
        }
 protected override void Validate(object arguments, EngineIntrinsics engineIntrinsics)
 {
     if (!Uri.IsWellFormedUriString(arguments.ToString(), UriKind.Absolute))
      {
          throw new ValidationMetadataException("{0} is not a valid uri.".format(arguments.ToString()));
      }
 }
 protected override void Validate(object arguments, EngineIntrinsics engineIntrinsics)
 {
     IEnumerable enumerable = null;
     IEnumerator enumerator = null;
     if ((arguments == null) || (arguments == AutomationNull.Value))
     {
         throw new ValidationMetadataException("ArgumentIsNull", null, Metadata.ValidateNotNullFailure, new object[0]);
     }
     enumerable = arguments as IEnumerable;
     if (enumerable != null)
     {
         foreach (object obj2 in enumerable)
         {
             if ((obj2 == null) || (obj2 == AutomationNull.Value))
             {
                 throw new ValidationMetadataException("ArgumentIsNull", null, Metadata.ValidateNotNullCollectionFailure, new object[0]);
             }
         }
     }
     else
     {
         enumerator = arguments as IEnumerator;
         if (enumerator != null)
         {
             while (enumerator.MoveNext())
             {
                 if ((enumerator.Current == null) || (enumerator.Current == AutomationNull.Value))
                 {
                     throw new ValidationMetadataException("ArgumentIsNull", null, Metadata.ValidateNotNullCollectionFailure, new object[0]);
                 }
             }
         }
     }
 }
        protected override void Validate(object arguments, EngineIntrinsics engineIntrinsics)
        {
            // Null object test
            if (arguments == null)
            {
                throw new ValidationMetadataException("Parameter arguments can not be empty or null.");
            }

            // String test
            if (String.IsNullOrEmpty(arguments as String))
            {
                throw new ValidationMetadataException("Parameter arguments can not be empty or null.");
            }

            // Collections test
            IEnumerable collection = arguments as IEnumerable;

            if (collection != null)
            {
                object obj = collection.GetEnumerator().Current;
                if (obj == null)
                {
                    throw new ValidationMetadataException("Parameter arguments can not be empty or null.");
                }
            }
        }
		protected override void Validate(object arguments, EngineIntrinsics engineIntrinsics)
		{
			if (arguments == null || arguments == AutomationNull.Value)
			{
				return;
			}
			else
			{
				object[] objArray = arguments as object[];
				if (objArray != null)
				{
					object[] objArray1 = objArray;
					int num = 0;
					while (num < (int)objArray1.Length)
					{
						object obj = objArray1[num];
						if ((obj == null || obj == AutomationNull.Value) && (int)objArray.Length > 1)
						{
							throw new ValidationMetadataException(string.Format(CultureInfo.CurrentCulture, StringResources.InvalidNullValue, new object[0]));
						}
						else
						{
							num++;
						}
					}
					return;
				}
				else
				{
					return;
				}
			}
		}
		protected override void Validate(object arguments, EngineIntrinsics engineIntrinsics)
		{
			if (arguments == null || arguments == AutomationNull.Value)
			{
				return;
			}
			else
			{
				IEnumerable enumerable = arguments as IEnumerable;
				if (enumerable != null)
				{
					HashSet<object> objs = new HashSet<object>();
					foreach (object obj in enumerable)
					{
						if (!objs.Contains(obj))
						{
							objs.Add(obj);
						}
						else
						{
							object[] str = new object[1];
							str[0] = obj.ToString();
							throw new ValidationMetadataException(string.Format(CultureInfo.CurrentCulture, StringResources.DuplicateValuesSpecified, str));
						}
					}
					return;
				}
				else
				{
					return;
				}
			}
		}
		protected override void Validate(object arguments, EngineIntrinsics engineIntrinsics)
		{
			if (arguments == null || arguments == AutomationNull.Value)
			{
				return;
			}
			else
			{
				int? nullable = (int?)(arguments as int?);
				if (nullable.HasValue)
				{
					if (nullable.Value >= this._minRange)
					{
						if (nullable.Value > this._maxRange)
						{
							object[] objArray = new object[2];
							objArray[0] = nullable;
							objArray[1] = this._maxRange;
							throw new ValidationMetadataException(string.Format(CultureInfo.CurrentCulture, StringResources.ValidateRangeGreaterThanMaxValue, objArray));
						}
					}
					else
					{
						object[] objArray1 = new object[2];
						objArray1[0] = nullable;
						objArray1[1] = this._minRange;
						throw new ValidationMetadataException(string.Format(CultureInfo.CurrentCulture, StringResources.ValidateRangeLessThanMinValue, objArray1));
					}
				}
				return;
			}
		}
        public override object Transform(EngineIntrinsics engineIntrinsics, object inputData)
        {
            if (null == inputData)
            {
                return null;
            }

            var pso = PSObject.AsPSObject(inputData);
            FileInfo file = pso.BaseObject as FileInfo;
            if (null == file)
            {
                string filePath = pso.BaseObject as string;
                if (null != filePath)
                {
                    file = new FileInfo(filePath);
                }
            }

            if (null == file || ! file.Exists )
            {
                return inputData;
            }

            var results = engineIntrinsics.InvokeCommand.InvokeScript("$input | get-packageXml", false, PipelineResultTypes.None, new ArrayList{inputData}, null);
            return results.FirstOrDefault();
        }
        public override object Transform(EngineIntrinsics engineIntrinsics, object inputData)
        {
            if (null == inputData)
            {
                return inputData;
            }

            var inputObject = inputData.ToPSObject().BaseObject;

            if (!(inputObject is ScriptBlock))
            {
                return inputData;
            }

            var script = inputObject as ScriptBlock;

            var dataSource = new PowerShellDataSource
            {
                Name = script.ToString(),
                ScriptBlock = script.ToString(),
                Trigger = new ImmediateTrigger()
            };

            //TODO: add datasource to datasources: drive
            var drive = engineIntrinsics.InvokeCommand.InvokeScript("get-psdrive datasources") as IDriveOf<IPowerShellDataSource>;
            drive.Add(dataSource);

            return dataSource;
        }
 /// <summary>
 /// Validates that a variable name is valid with or without optional append character "+".
 /// </summary>
 /// <param name="arguments">The arguments to validate.</param>
 /// <param name="engineIntrinsics"><see cref="EngineIntrinsics"/> for additional information.</param>
 /// <exception cref="ValidationMetadataException">The variable name is invalid.</exception>
 protected override void Validate(object arguments, EngineIntrinsics engineIntrinsics)
 {
     if (!this.Validate(arguments))
     {
         throw new ValidationMetadataException(Properties.Resources.Error_InvalidVariableName);
     }
 }
Exemple #11
0
        protected override void Validate(object arguments, EngineIntrinsics engineIntrinsics)
        {
            int _total = 0;

            if (arguments != null)
            {
                IEnumerable _collection = arguments as IEnumerable;
                if (_collection != null)
                {
                    while (_collection.GetEnumerator().MoveNext())
                    {
                        _total++;
                    }
                }

                else _total = 1;
            }

            if (_total < MinLength)
            {
                throw new ValidationMetadataException("Argument requires minimum of " + MinLength + " values.");
            }

            if (_total > MaxLength)
            {
                throw new ValidationMetadataException("Argument requires maximum of " + MaxLength + " values.");
            }
        }
 public override object Transform(EngineIntrinsics engineIntrinsics, object inputData)
 {
     var enumerable = inputData as IEnumerable<object> ?? new[] { inputData };
     return enumerable.Select(
             inputElement => _typeTransformationAttribute.Transform(engineIntrinsics, inputElement)
             ).ToArray();
 }
 protected override void Validate(object arguments, EngineIntrinsics engineIntrinsics)
 {
     var webAppName = arguments as string;
     if (CmdletHelpers.IsDeploymentSlot(webAppName))
     {
         throw new ValidationMetadataException(string.Format("Specified resource '{0}' is a non-production web app slot. Please use the AzureRMWebAppSlot cmdlets to manage this resource", webAppName));
     }
 }
Exemple #14
0
 protected override void Validate(object arguments, EngineIntrinsics engineIntrinsics)
 {
     Version version = arguments as Version;
     if ((version == null) || !PSVersionInfo.IsValidPSVersion(version))
     {
         throw new ValidationMetadataException("InvalidPSVersion", null, Metadata.ValidateVersionFailure, new object[] { arguments });
     }
 }
Exemple #15
0
 internal ParameterBinderBase(System.Management.Automation.InvocationInfo invocationInfo, System.Management.Automation.ExecutionContext context, InternalCommand command)
 {
     this.RecordBoundParameters = true;
     bindingTracer.ShowHeaders = false;
     this.command = command;
     this.invocationInfo = invocationInfo;
     this.context = context;
     this.engine = context.EngineIntrinsics;
 }
 public override object Transform(EngineIntrinsics engineIntrinsics, object inputData)
 {
     string str;
     if (!LanguagePrimitives.TryConvertTo<string>(inputData, out str) || (((!string.Equals(str, "unknown", StringComparison.OrdinalIgnoreCase) && !string.Equals(str, "string", StringComparison.OrdinalIgnoreCase)) && (!string.Equals(str, "unicode", StringComparison.OrdinalIgnoreCase) && !string.Equals(str, "bigendianunicode", StringComparison.OrdinalIgnoreCase))) && (((!string.Equals(str, "utf8", StringComparison.OrdinalIgnoreCase) && !string.Equals(str, "utf7", StringComparison.OrdinalIgnoreCase)) && (!string.Equals(str, "utf32", StringComparison.OrdinalIgnoreCase) && !string.Equals(str, "ascii", StringComparison.OrdinalIgnoreCase))) && (!string.Equals(str, "default", StringComparison.OrdinalIgnoreCase) && !string.Equals(str, "oem", StringComparison.OrdinalIgnoreCase)))))
     {
         return inputData;
     }
     return EncodingConversion.Convert(null, str);
 }
 protected override void Validate(object arguments, EngineIntrinsics engineIntrinsics)
 {
     int count = 0;
     if ((arguments == null) || (arguments == AutomationNull.Value))
     {
         count = 0;
     }
     else
     {
         IList list = arguments as IList;
         if (list != null)
         {
             count = (int) list.Count;
         }
         else
         {
             ICollection is2 = arguments as ICollection;
             if (is2 != null)
             {
                 count = (int) is2.Count;
             }
             else
             {
                 IEnumerable enumerable = arguments as IEnumerable;
                 if (enumerable != null)
                 {
                     IEnumerator enumerator2 = enumerable.GetEnumerator();
                     while (enumerator2.MoveNext())
                     {
                         count++;
                     }
                 }
                 else
                 {
                     IEnumerator enumerator = arguments as IEnumerator;
                     if (enumerator == null)
                     {
                         throw new ValidationMetadataException("NotAnArrayParameter", null, Metadata.ValidateCountNotInArray, new object[0]);
                     }
                     while (enumerator.MoveNext())
                     {
                         count++;
                     }
                 }
             }
         }
     }
     if (count < this.minLength)
     {
         throw new ValidationMetadataException("ValidateCountSmallerThanMin", null, Metadata.ValidateCountMinLengthFailure, new object[] { this.minLength, count });
     }
     if (count > this.maxLength)
     {
         throw new ValidationMetadataException("ValidateCountGreaterThanMax", null, Metadata.ValidateCountMaxLengthFailure, new object[] { this.maxLength, count });
     }
 }
        protected override void Validate(object arguments, EngineIntrinsics engineIntrinsics)
        {
            var serverFarm = arguments as ServerFarmWithRichSku;
            if (serverFarm == null)
            {
                throw new ValidationMetadataException("Argument 'ServerFarm' must be of type Microsoft.Azure.Management.WebSites.Models.ServerFarmWithRichSku");
            }

            ValidateSku(serverFarm.Sku);
        }
Exemple #19
0
 public void Begin(bool expectInput, EngineIntrinsics contextToRedirectTo)
 {
     if (contextToRedirectTo == null)
     {
         throw new ArgumentNullException("contextToRedirectTo");
     }
     CommandProcessorBase currentCommandProcessor = contextToRedirectTo.SessionState.Internal.ExecutionContext.CurrentCommandProcessor;
     ICommandRuntime commandRuntime = (currentCommandProcessor == null) ? null : currentCommandProcessor.CommandRuntime;
     this.Begin(expectInput, commandRuntime);
 }
Exemple #20
0
        /// <summary>
        /// Transforms a string or integer to an <see cref="System.Text.Encoding"/>.
        /// </summary>
        /// <param name="engineIntrinsics">Provides access to the APIs for managing the transformation context.</param>
        /// <param name="inputData">The parameter argument that is to be transformed.</param>
        /// <returns>The transformed object.</returns>
        public override object Transform(EngineIntrinsics engineIntrinsics, object inputData)
        {
            if (null != inputData)
            {
                var converter = new EncodingConverter();
                if (converter.CanConvertFrom(inputData.GetType()))
                {
                    return converter.ConvertFrom(inputData);
                }
            }

            return inputData;
        }
        protected override void Validate(object arguments, EngineIntrinsics engineIntrinsics)
        {
            if (arguments == null)
            {
                throw new ValidationMetadataException("Specify a parameter of type 'System.Guid' and try again.");
            }

            Guid param = (Guid)arguments;
            if (param == Guid.Empty)
            {
                throw new ValidationMetadataException("Specify a non empty value of type 'System.Guid' and try again.");
            }
        }
        public override object Transform(EngineIntrinsics engineIntrinsics, object inputData)
        {
            if (null == inputData)
            {
                inputData = ".";
            }

            var path = inputData.ToString();

            var drive = MetadataHelpers.GetEntityDriveFromPSPath(engineIntrinsics.SessionState.Path, path);

            return drive;
        }
        protected override void Validate(object arguments, EngineIntrinsics engineIntrinsics)
        {
            string str = arguments as string;
            if (string.IsNullOrEmpty(str))
            {
                throw new PSArgumentNullException();
            }

            if (!File.Exists(str))
            {
                throw new PSArgumentException("File not found");
            }
        }
        public override object Transform(EngineIntrinsics engineIntrinsics, object inputData)
        {
            if (null == inputData || typeof(string) != inputData.GetType())
            {
                return inputData;
            }

            var path = inputData.ToString();

            var entity = MetadataHelpers.GetEntityFromPSPath(engineIntrinsics, path);

            return entity ?? inputData;
        }
 /// <summary>
 /// Check against legal values.
 /// </summary>
 /// <param name="arguments"></param>
 /// <param name="engineIntrinsics"></param>
 protected override void Validate(object arguments, EngineIntrinsics engineIntrinsics)
 {
     var s = arguments as string;
     if (s == null)
     {
         throw new ValidationMetadataException("Argument is not a string.");
     }
     if (!_validLocations.Contains(s))
     {
         var err = _validLocations.Aggregate(new StringBuilder(), (bld, loc) => bld.Append($" {loc}"));
         throw new ValidationMetadataException($"Illegal value for Location - possible values:{err.ToString()}");
     }
 }
        public override object Transform(EngineIntrinsics engineIntrinsics, object inputData)
        {
            if (null == inputData)
            {
                return null;
            }

            var inputType = inputData.ToPSObject().BaseObject.GetType();

            if( inputType.IsAssignableFrom( typeof( short )) )
            {
                return TimeSpan.FromMilliseconds((double) inputData);
            }

            if (typeof(string) == inputType)
            {
                TimeSpan result = TimeSpan.MinValue;
                var s = inputData.ToString();
                if( TimeSpan.TryParse( s, out result ) )
                {
                    return result;
                }

                Regex re = new Regex(@"(?<n>[\.0-9]+)((?<ticks>t.*)|(?<milliseconds>ms.*)|(?<seconds>s.*)|(?<minutes>m.*)|(?<hours>h.*)||(?<days>d.*))", RegexOptions.IgnoreCase | RegexOptions.Singleline);
                var match = re.Match(s);
                if( match.Success )
                {
                    var l = match.Groups["l"].Value;
                    var n = Double.Parse(match.Groups["n"].Value);

                    var map = new Dictionary<string, Func<double,TimeSpan>>
                                  {
                                      {"milliseconds", d => TimeSpan.FromMilliseconds(d)},
                                      {"seconds", d => TimeSpan.FromSeconds(d)},
                                      {"minutes", d => TimeSpan.FromMinutes(d)},
                                      {"hours", d => TimeSpan.FromHours(d)},
                                      {"days", d => TimeSpan.FromDays(d)},
                                      {"ticks", d => TimeSpan.FromTicks((int) d)}
                                  };

                    foreach( var pair in map )
                    {
                        if( match.Groups[pair.Key].Success)
                        {
                            return pair.Value(n);
                        }
                    }
                }
            }
            return inputData;
        }
 public CmdletParameterBinder(CmdletInfo cmdletInfo, Cmdlet cmdlet)
 {
     _cmdletInfo = cmdletInfo;
     _cmdlet = cmdlet;
     _defaultValues = new Dictionary<MemberInfo, object>();
     _boundParameters = new Collection<MemberInfo>();
     _candidateParameterSets = _cmdletInfo.ParameterSets.ToList();
     _commandLineValuesBackup = new Dictionary<MemberInfo, object>();
     _activeSet = null;
     _defaultSet = null;
     _hasDefaultSet = true;
     _commonParameters = (from parameter in CommonCmdletParameters.CommonParameterSetInfo.Parameters
                          select parameter.MemberInfo).ToList();
     _engineIntrinsics = new EngineIntrinsics(_cmdlet.ExecutionContext);
 }
        public override object Transform(EngineIntrinsics engineIntrinsics, object inputData)
        {
            var results = engineIntrinsics.InvokeCommand.InvokeScript(
                engineIntrinsics.SessionState,
                _script,
                inputData
                );

            if( null == results || 0 == results.Count )
            {
                return inputData;
            }

            return results[0];
        }
Exemple #29
0
 public CmdletParameterBinder(CmdletInfo cmdletInfo, Cmdlet cmdlet)
 {
     _cmdletInfo = cmdletInfo;
     _cmdlet = cmdlet;
     _defaultValues = new Dictionary<MemberInfo, object>();
     _boundParameters = new Collection<MemberInfo>();
     _candidateParameterSets = _cmdletInfo.ParameterSets.ToList();
     _commandLineValuesBackup = new Dictionary<MemberInfo, object>();
     _activeSet = null;
     _defaultSet = null;
     _hasDefaultSet = true;
     _bindDestinationLookup = new Dictionary<MemberInfo, object>();
     _engineIntrinsics = new EngineIntrinsics(_cmdlet.ExecutionContext);
     // make sure common parameters are set in the CommonParameter member object, not the cmdlet itself
     AddBindDestionations(CommonCmdletParameters.ParameterDiscovery, _cmdlet.CommonParameters);
 }
        object TransformItem( EngineIntrinsics engineIntrinsics, object inputData )
        {
            var inputObject = inputData.ToPSObject().BaseObject;

            var scriptBlock = inputObject as ScriptBlock;
            if (null == scriptBlock)
            {
                return inputData;
            }

            scriptBlock = ScriptBlock.Create(  "if( -not($_) ){ $_ = $this; } " + scriptBlock );

            var property = new PSScriptProperty( "_" + Guid.NewGuid().ToString("N"), scriptBlock);

            return property;
        }
 protected abstract void Validate(object arguments, EngineIntrinsics engineIntrinsics);
 public abstract object Transform(EngineIntrinsics engineIntrinsics, object inputData);
        internal object Transform(EngineIntrinsics engineIntrinsics, object inputData, bool bindingParameters, bool bindingScriptCmdlet)
        {
            if (_convertTypes == null)
            {
                return(inputData);
            }

            object result = inputData;

            try
            {
                for (int i = 0; i < _convertTypes.Length; i++)
                {
                    if (bindingParameters)
                    {
                        // We should not be doing a conversion here if [ref] is the last type.
                        // When [ref] appears in an argument list, it is used for checking only.
                        // No Conversion should be done.
                        if (_convertTypes[i].Equals(typeof(System.Management.Automation.PSReference)))
                        {
                            object   temp;
                            PSObject mshObject = result as PSObject;
                            if (mshObject != null)
                            {
                                temp = mshObject.BaseObject;
                            }
                            else
                            {
                                temp = result;
                            }

                            PSReference reference = temp as PSReference;

                            if (reference == null)
                            {
                                throw new PSInvalidCastException("InvalidCastExceptionReferenceTypeExpected", null,
                                                                 ExtendedTypeSystem.ReferenceTypeExpected);
                            }
                        }
                        else
                        {
                            object   temp;
                            PSObject mshObject = result as PSObject;
                            if (mshObject != null)
                            {
                                temp = mshObject.BaseObject;
                            }
                            else
                            {
                                temp = result;
                            }

                            // If a non-ref type is expected but currently passed in is a ref, do an implicit dereference.
                            PSReference reference = temp as PSReference;

                            if (reference != null)
                            {
                                result = reference.Value;
                            }

                            if (bindingScriptCmdlet && _convertTypes[i] == typeof(string))
                            {
                                // Don't allow conversion from array to string in script w/ cmdlet binding.  Allow
                                // the conversion for ordinary script parameter binding for V1 compatibility.
                                temp = PSObject.Base(result);
                                if (temp != null && temp.GetType().IsArray)
                                {
                                    throw new PSInvalidCastException("InvalidCastFromAnyTypeToString", null,
                                                                     ExtendedTypeSystem.InvalidCastCannotRetrieveString);
                                }
                            }
                        }
                    }

                    //BUGBUG
                    //NTRAID#Windows Out of Band Releases - 930116 - 03/14/06
                    //handling special case for boolean, switchparameter and Nullable<bool>
                    //These parameter types will not be converted if the incoming value types are not
                    //one of the accepted categories - $true/$false or numbers (0 or otherwise)
                    if (LanguagePrimitives.IsBoolOrSwitchParameterType(_convertTypes[i]))
                    {
                        CheckBoolValue(result, _convertTypes[i]);
                    }

                    if (bindingScriptCmdlet)
                    {
                        // Check for conversion to something like bool[] or ICollection<bool>, but only for cmdlet binding
                        // to stay compatible with V1.
                        ParameterCollectionTypeInformation collectionTypeInfo = new ParameterCollectionTypeInformation(_convertTypes[i]);
                        if (collectionTypeInfo.ParameterCollectionType != ParameterCollectionType.NotCollection &&
                            LanguagePrimitives.IsBoolOrSwitchParameterType(collectionTypeInfo.ElementType))
                        {
                            IList currentValueAsIList = ParameterBinderBase.GetIList(result);
                            if (currentValueAsIList != null)
                            {
                                foreach (object val in currentValueAsIList)
                                {
                                    CheckBoolValue(val, collectionTypeInfo.ElementType);
                                }
                            }
                            else
                            {
                                CheckBoolValue(result, collectionTypeInfo.ElementType);
                            }
                        }
                    }

                    result = LanguagePrimitives.ConvertTo(result, _convertTypes[i], CultureInfo.InvariantCulture);

                    // Do validation of invalid direct variable assignments which are allowed to
                    // be used for parameters.
                    //
                    // Note - this is duplicated in ExecutionContext.cs as parameter binding for script cmdlets can avoid this code path.
                    if ((!bindingScriptCmdlet) && (!bindingParameters))
                    {
                        // ActionPreference of Suspend is not supported as a preference variable. We can only block "Suspend"
                        // during variable assignment (here) - "Ignore" is blocked during variable retrieval.
                        if (_convertTypes[i] == typeof(ActionPreference))
                        {
                            ActionPreference resultPreference = (ActionPreference)result;

                            if (resultPreference == ActionPreference.Suspend)
                            {
                                throw new PSInvalidCastException("InvalidActionPreference", null, ErrorPackage.UnsupportedPreferenceVariable, resultPreference);
                            }
                        }
                    }
                }
            }
            catch (PSInvalidCastException e)
            {
                throw new ArgumentTransformationMetadataException(e.Message, e);
            }

            return(result);
        }
 public override object Transform(EngineIntrinsics engineIntrinsics, object inputData)
 {
     return(Transform(engineIntrinsics, inputData, false, false));
 }
 // internals
 internal void InternalValidate(object o, EngineIntrinsics engineIntrinsics)
 {
     Validate(o, engineIntrinsics);
 }