public void ValidateHTTPProtocolConfiguration(PSNetworkWatcherConnectionMonitorHttpConfiguration httpProtocolConfiguration)
        {
            if (httpProtocolConfiguration.Port != null)
            {
                this.ValidatePort(httpProtocolConfiguration.Port);
            }

            if (!string.IsNullOrEmpty(httpProtocolConfiguration.Method) && !httpProtocolConfiguration.Method.Equals("GET", StringComparison.OrdinalIgnoreCase) &&
                !httpProtocolConfiguration.Method.Equals("POST", StringComparison.OrdinalIgnoreCase))
            {
                throw new PSArgumentException(Properties.Resources.UnsupportedHTTPMethod);
            }

            if (!string.IsNullOrEmpty(httpProtocolConfiguration.Path) && !Uri.IsWellFormedUriString(httpProtocolConfiguration.Path, UriKind.Relative))
            {
                throw new PSArgumentException(Properties.Resources.InvalidHttpUriPathFormat);
            }

            if (!this.IsValidStatusCodeRanges(httpProtocolConfiguration.ValidStatusCodeRanges))
            {
                throw new PSArgumentException(Properties.Resources.InvalidStatusCodeRangesFormat);
            }

            this.ValidateRequestHeaders(httpProtocolConfiguration.RequestHeaders);
        }
Example #2
0
        public override void Execute()
        {
            base.Execute();

            PSNetworkWatcherConnectionMonitorProtocolConfiguration protocolConfiguration;

            if (TcpProtocol.IsPresent)
            {
                protocolConfiguration = new PSNetworkWatcherConnectionMonitorTcpConfiguration()
                {
                    Port = this.Port,
                    DisableTraceRoute       = this.DisableTraceRoute.IsPresent,
                    DestinationPortBehavior = this.DestinationPortBehavior
                };
            }
            else if (HttpProtocol.IsPresent)
            {
                protocolConfiguration = new PSNetworkWatcherConnectionMonitorHttpConfiguration()
                {
                    Port                  = this.Port,
                    Method                = this.Method,
                    Path                  = this.Path,
                    RequestHeaders        = this.GetHeaders(),
                    ValidStatusCodeRanges = this.ValidStatusCodeRange?.ToList(),
                    PreferHTTPS           = this.PreferHTTPS.IsPresent
                };
            }
            else if (IcmpProtocol.IsPresent)
            {
                protocolConfiguration = new PSNetworkWatcherConnectionMonitorIcmpConfiguration()
                {
                    DisableTraceRoute = this.DisableTraceRoute.IsPresent
                };
            }
            else
            {
                throw new ArgumentException("Parameter set shall be TCP, HTTP, or ICMP");
            }

            this.Validate(protocolConfiguration);

            WriteObject(protocolConfiguration);
        }
        private List <HTTPHeader> GetRequestHeaders(PSNetworkWatcherConnectionMonitorHttpConfiguration httpConfiguration)
        {
            if (httpConfiguration.RequestHeaders == null)
            {
                return(null);
            }

            var requestHeaders = new List <HTTPHeader>();

            foreach (PSHTTPHeader header in httpConfiguration.RequestHeaders)
            {
                requestHeaders.Add(
                    new HTTPHeader()
                {
                    Name  = header.Name,
                    Value = header.Value
                });
            }

            return(requestHeaders);
        }