public PluginExecutionResult Execute(PluginExecutionData executionData)
        {
            CtcSettings.Initialize(executionData);

            TelnetSnmpActivityData activityData = executionData.GetMetadata <TelnetSnmpActivityData>(CtcMetadataConverter.Converters);

            if (null == _tests)
            {
                _tests = new TelnetTests(activityData);
            }
            PrinterFamilies family = (PrinterFamilies)Enum.Parse(typeof(PrinterFamilies), activityData.ProductCategory);

            // create instance of ews adapter
            EwsWrapper.Instance().Create(family, activityData.ProductName, activityData.PrinterIP, activityData.SitemapsVersion, BrowserModel.Firefox);

            EwsWrapper.Instance().Start();

            // Enable telnet as after cold reset telnet will be disabled by default in the new product versions.
            EwsWrapper.Instance().SetTelnet();

            foreach (int testNumber in activityData.TestNumbers)
            {
                try
                {
                    ExecutionServices.SessionRuntime.AsInternal().WaitIfPaused();
                    _tests.RunTest(executionData, testNumber, IPAddress.Parse(activityData.PrinterIP), (ProductFamilies)Enum.Parse(typeof(ProductFamilies), activityData.ProductCategory));
                }
                catch (Exception pauseException)
                {
                    TraceFactory.Logger.Fatal("Error while pausing: " + pauseException.Message);
                }
            }

            return(new PluginExecutionResult(PluginResult.Passed));
        }
예제 #2
0
        public PluginExecutionResult Execute(PluginExecutionData executionData)
        {
            CtcSettings.Initialize(executionData);

            // create activity data
            FirewallActivityData activityData = executionData.GetMetadata <FirewallActivityData>(CtcMetadataConverter.Converters);
            PrinterFamilies      family       = (PrinterFamilies)Enum.Parse(typeof(PrinterFamilies), activityData.ProductFamily);

            // Instance for EWS adapter and Start WebDriver
            EwsWrapper.Instance().Create(family, activityData.ProductName, activityData.IPv4Address, Path.Combine(activityData.SitemapPath, activityData.SitemapsVersion), BrowserModel.Firefox);
            EwsWrapper.Instance().Start();
            EwsWrapper.Instance().WakeUpPrinter();
            EwsWrapper.Instance().SetWSDiscovery(true);
            EwsWrapper.Instance().SetDHCPv6OnStartup(true);
            EwsWrapper.Instance().EnableSnmpv1v2ReadWriteAccess();

            // Get All IPv6 Addresses

            Printer.Printer printer = PrinterFactory.Create(family, IPAddress.Parse(activityData.IPv4Address));
            activityData.IPv6LinkLocalAddress = printer.IPv6LinkLocalAddress?.ToString() ?? string.Empty;
            activityData.IPv6StatefulAddress  = printer.IPv6StateFullAddress?.ToString() ?? string.Empty;
            activityData.IPv6StatelessAddress = printer.IPv6StatelessAddresses.Count == 0 ? string.Empty : printer.IPv6StatelessAddresses[0].ToString();

            // Instance for SNMP wrapper
            SnmpWrapper.Instance().Create(activityData.IPv4Address);

            // Instance for Telnet wrapper
            TelnetWrapper.Instance().Create(activityData.IPv4Address);

            // Instance for Firewall Tests
            if (null == _tests)
            {
                _tests = new FirewallTests(activityData);
            }

            foreach (int testNumber in activityData.SelectedTests)
            {
                try
                {
                    ExecutionServices.SessionRuntime.AsInternal().WaitIfPaused();
                    _tests.RunTest(executionData, testNumber, IPAddress.Parse(activityData.IPv4Address), (ProductFamilies)Enum.Parse(typeof(ProductFamilies), activityData.ProductFamily));
                }
                catch (Exception exception)
                {
                    TraceFactory.Logger.Info("Error while executing test {0} with exception {1}. \n".FormatWith(testNumber, exception.Message));
                }
            }

            EwsWrapper.Instance().Stop();

            return(new PluginExecutionResult(PluginResult.Passed));
        }
예제 #3
0
        public PluginExecutionResult Execute(PluginExecutionData executionData)
        {
            CtcSettings.Initialize(executionData);

            // create activity data
            DiscoveryActivityData activityData = executionData.GetMetadata <DiscoveryActivityData>(CtcMetadataConverter.Converters);
            PrinterFamilies       family       = (PrinterFamilies)Enum.Parse(typeof(PrinterFamilies), activityData.ProductFamily);

            // create instance of ews adapter
            EwsWrapper.Instance().Create(family, activityData.ProductName, activityData.IPv4Address, Path.Combine(activityData.SitemapPath,
                                                                                                                  activityData.SitemapsVersion), BrowserModel.Firefox);

            //create instance of SNMP wrapper
            SnmpWrapper.Instance().Create(activityData.IPv4Address);

            //create instance of Telnet wrapper
            TelnetWrapper.Instance().Create(activityData.IPv4Address);

            EwsWrapper.Instance().Start();

            EwsWrapper.Instance().WakeUpPrinter();

            EwsWrapper.Instance().SetAdvancedOptions();

            EwsWrapper.Instance().EnableSnmpv1v2ReadWriteAccess();

            BonjourServiceInstallation();

            Printer.Printer printer = PrinterFactory.Create(activityData.ProductFamily, activityData.IPv4Address);
            activityData.PrinterMacAddress = printer.MacAddress.Replace(":", string.Empty);

            // create network discovery tests
            if (null == _networkDiscoveryTests)
            {
                _networkDiscoveryTests = new DiscoveryTests(activityData);
            }

            foreach (int testNumber in activityData.SelectedTests)
            {
                try
                {
                    ExecutionServices.SessionRuntime.AsInternal().WaitIfPaused();
                    _networkDiscoveryTests.RunTest(executionData, testNumber, IPAddress.Parse(activityData.IPv4Address), (ProductFamilies)Enum.Parse(typeof(ProductFamilies), activityData.ProductFamily));
                }
                catch (Exception e)
                {
                    TraceFactory.Logger.Info("Error while executing test:{0}  \n ".FormatWith(testNumber, e.Message));
                }
            }

            return(new PluginExecutionResult(PluginResult.Passed));
        }
예제 #4
0
        public PluginExecutionResult Execute(PluginExecutionData executionData)
        {
            CtcSettings.Initialize(executionData);

            // create activity data
            DotOneXActivityData activityData = executionData.GetMetadata <DotOneXActivityData>(CtcMetadataConverter.Converters);
            PrinterFamilies     family       = (PrinterFamilies)Enum.Parse(typeof(PrinterFamilies), activityData.ProductFamily);

            activityData.DotOneXUserName = DOT1X_USERNAME.FormatWith(activityData.RadiusServerType.ToString().ToLower(CultureInfo.CurrentCulture));
            activityData.DotOneXPassword = DOT1X_PASSWORD;
            activityData.SharedSecret    = SHARED_SECRET;
            activityData.PolicyName      = NETWORK_POLICY;

            bool continueTest = true;

            while (continueTest && !NetworkUtil.PingUntilTimeout(IPAddress.Parse(activityData.Ipv4Address), TimeSpan.FromSeconds(30)))
            {
                continueTest = DotOneXTemplates.ShowErrorPopUp("Printer: {0} is not available.\nPlease cold reset the printer.".FormatWith(activityData.Ipv4Address));
            }

            if (!continueTest)
            {
                return(new PluginExecutionResult(PluginResult.Failed, "Printer: {0} is not available.\nPlease cold reset the printer.".FormatWith(activityData.Ipv4Address)));
            }

            // create instance of ews adapter
            EwsWrapper.Instance().Create(family, activityData.ProductName, activityData.Ipv4Address, Path.Combine(activityData.SitemapPath, activityData.SiteMapVersion), BrowserModel.Firefox);

            EwsWrapper.Instance().Start();

            EwsWrapper.Instance().WakeUpPrinter();

            EwsWrapper.Instance().EnableSnmpv1v2ReadWriteAccess();

            SnmpWrapper.Instance().Create(activityData.Ipv4Address);
            SnmpWrapper.Instance().SetCommunityName("public");

            TelnetWrapper.Instance().Create(activityData.Ipv4Address);

            //TODO: Migration issue even thought it is not migration issue why it is commented
            //EwsWrapper.Instance().SetWSDiscovery(true);

            Printer.Printer printer = PrinterFactory.Create(activityData.ProductFamily, activityData.Ipv4Address);
            activityData.MacAddress = printer.MacAddress;

            using (DhcpApplicationServiceClient dhcpClient = DhcpApplicationServiceClient.Create(activityData.DhcpServerIp))
            {
                string scope = dhcpClient.Channel.GetDhcpScopeIP(activityData.DhcpServerIp);
                dhcpClient.Channel.DeleteReservation(activityData.DhcpServerIp, scope, activityData.Ipv4Address, activityData.MacAddress);

                if (dhcpClient.Channel.CreateReservation(activityData.DhcpServerIp, scope, activityData.Ipv4Address, activityData.MacAddress, ReservationType.Both))
                {
                    TraceFactory.Logger.Info("Successfully created reservation for IP address: {0}, Mac address: {1} for {2}".FormatWith(activityData.Ipv4Address, activityData.MacAddress, ReservationType.Both));
                }
                else
                {
                    TraceFactory.Logger.Info("Failed to create reservation for IP address: {0}, Mac address: {1} for {2}".FormatWith(activityData.Ipv4Address, activityData.MacAddress, ReservationType.Both));
                    return(new PluginExecutionResult(PluginResult.Failed, "Failed to create reservation for IP address: {0}, Mac address: {1} for {2}".FormatWith(activityData.Ipv4Address, activityData.MacAddress, ReservationType.Both)));
                }
            }

            if (!ConfigureRadiusServer(activityData))
            {
                return(new PluginExecutionResult(PluginResult.Failed, "Failed to configure radius server"));
            }

            if (!ConfigureSwitch(activityData))
            {
                return(new PluginExecutionResult(PluginResult.Failed, "Failed to configure switch"));
            }

            activityData.SessionId = executionData.SessionId;

            if (null == _tests)
            {
                _tests = new DotOneXTests(activityData);
            }

            // Execute the selected tests
            foreach (int testNumber in activityData.SelectedTests)
            {
                try
                {
                    ExecutionServices.SessionRuntime.AsInternal().WaitIfPaused();
                    _tests.RunTest(executionData, testNumber, IPAddress.Parse(activityData.Ipv4Address), (ProductFamilies)Enum.Parse(typeof(ProductFamilies), activityData.ProductFamily));
                }
                catch (Exception ex)
                {
                    TraceFactory.Logger.Fatal("Error while executing Test:{0} \n".FormatWith(testNumber, ex.Message));
                }
            }

            EwsWrapper.Instance().Stop();

            return(new PluginExecutionResult(PluginResult.Passed));
        }
        public PluginExecutionResult Execute(PluginExecutionData executionData)
        {
            CtcSettings.Initialize(executionData);

            WebProxyActivityData activityData = executionData.GetMetadata <WebProxyActivityData>(CtcMetadataConverter.Converters);

            #region Scenario Prerequisites

            //Check the Windows Server Service is up and running on all servers
            CtcUtility.StartService("WindowsServerService", activityData.PrimaryDHCPServerIPAddress);
            CtcUtility.StartService("WindowsServerService", activityData.UnsecureWebProxyServerIPAddress);
            CtcUtility.StartService("WindowsServerService", activityData.SecureWebProxyServerIPAddress);
            CtcUtility.StartService("WindowsServerService", activityData.WPADServerIPAddress);

            //Add WPAD entry and Domain Name on the DHCP Server
            DhcpApplicationServiceClient serviceFunction = DhcpApplicationServiceClient.Create(activityData.PrimaryDHCPServerIPAddress);
            activityData.PrimaryDHCPScopeIPAddress = serviceFunction.Channel.GetDhcpScopeIP(activityData.PrimaryDHCPServerIPAddress);
            serviceFunction.Channel.SetWPADServer(activityData.PrimaryDHCPServerIPAddress, activityData.PrimaryDHCPScopeIPAddress, activityData.cURLPathIPAddress);
            activityData.DomainName = "lfpctc.com";

            string recordType = "A";
            serviceFunction.Channel.SetDomainName(activityData.PrimaryDHCPServerIPAddress, activityData.PrimaryDHCPScopeIPAddress, activityData.DomainName);

            // Retrieving hostnames of all servers

            SystemConfigurationClient secureProxy = SystemConfigurationClient.Create(activityData.SecureWebProxyServerIPAddress);
            activityData.SecureWebProxyServerHostName = secureProxy.Channel.GetHostName();
            TraceFactory.Logger.Info("Secure Web Proxy hostname is {0}".FormatWith(activityData.SecureWebProxyServerHostName));

            SystemConfigurationClient unsecureProxy = SystemConfigurationClient.Create(activityData.UnsecureWebProxyServerIPAddress);
            activityData.UnsecureWebProxyServerHostName = unsecureProxy.Channel.GetHostName();
            TraceFactory.Logger.Info("Unsecure Web Proxy hostname is {0}".FormatWith(activityData.UnsecureWebProxyServerHostName));

            SystemConfigurationClient wpadServer = SystemConfigurationClient.Create(activityData.WPADServerIPAddress);
            activityData.WPADServerHostName = wpadServer.Channel.GetHostName();
            TraceFactory.Logger.Info("WPAD hostname is {0}".FormatWith(activityData.WPADServerHostName));

            //Add DNS entry for all servers on the DHCP/DNS server
            DnsApplicationServiceClient dnsClient = DnsApplicationServiceClient.Create(activityData.PrimaryDHCPServerIPAddress);
            dnsClient.Channel.AddDomain(activityData.DomainName);
            dnsClient.Channel.AddRecord(activityData.DomainName, activityData.SecureWebProxyServerHostName, recordType, activityData.SecureWebProxyServerIPAddress);
            dnsClient.Channel.AddRecord(activityData.DomainName, activityData.UnsecureWebProxyServerHostName, recordType, activityData.UnsecureWebProxyServerIPAddress);
            dnsClient.Channel.AddRecord(activityData.DomainName, activityData.WPADServerHostName, recordType, activityData.WPADServerIPAddress);

            string curlFqdn = string.Concat(activityData.WPADServerHostName, activityData.DomainName);
            activityData.cURLPathFQDN             = string.Concat("http://", curlFqdn, ":80/wpad.dat");
            activityData.SecureWebProxyServerFQDN = string.Concat(activityData.SecureWebProxyServerHostName, activityData.DomainName);

            TraceFactory.Logger.Info(activityData.cURLPathFQDN);
            TraceFactory.Logger.Info(activityData.SecureWebProxyServerFQDN);

            PrinterFamilies family  = (PrinterFamilies)Enum.Parse(typeof(PrinterFamilies), activityData.ProductFamily);
            Printer         printer = PrinterFactory.Create(family, IPAddress.Parse(activityData.WiredIPv4Address));

            // create instance of ews adapter
            EwsWrapper.Instance().Create(family, activityData.ProductName, activityData.WiredIPv4Address, Path.Combine(activityData.SitemapPath, activityData.SiteMapVersion), BrowserModel.Firefox);
            EwsWrapper.Instance().Start();

            //Create instance of SNMP Wrapper
            SnmpWrapper.Instance().Create(activityData.WiredIPv4Address);

            //Create instance of Telnet Wrapper
            TelnetWrapper.Instance().Create(activityData.WiredIPv4Address);

            //Wake up the printer and disable sleep mode
            EwsWrapper.Instance().WakeUpPrinter();
            printer.KeepAwake();

            EwsWrapper.Instance().EnableSnmpv1v2ReadWriteAccess();

            #endregion
            if (null == _webProxyTests)
            {
                _webProxyTests = new WebProxyTests(activityData);
            }

            // assign the session id to activity data
            activityData.SessionId = executionData.SessionId;

            foreach (int testNumber in activityData.SelectedTests)
            {
                try
                {
                    ExecutionServices.SessionRuntime.AsInternal().WaitIfPaused();
                    _webProxyTests.RunTest(executionData, testNumber, IPAddress.Parse(activityData.WiredIPv4Address), (ProductFamilies)Enum.Parse(typeof(ProductFamilies), activityData.ProductFamily));
                }
                catch (Exception generalException)
                {
                    TraceFactory.Logger.Info("Test {0} failed with error: {1}".FormatWith(testNumber, generalException.Message));
                }
            }

            EwsWrapper.Instance().Stop();

            return(new PluginExecutionResult(PluginResult.Passed));
        }
예제 #6
0
        public PluginExecutionResult Execute(PluginExecutionData executionData)
        {
            CtcSettings.Initialize(executionData);

            // create activity data
            CertificateManagementActivityData activityData = executionData.GetMetadata <CertificateManagementActivityData>(CtcMetadataConverter.Converters);
            var             ipV4Address = IPAddress.Parse(activityData.Ipv4Address);
            PrinterFamilies family      = (PrinterFamilies)Enum.Parse(typeof(PrinterFamilies), Enum <ProductFamilies> .Value(activityData.ProductFamily));

            // Create instance of ews adapter
            // Remember to give Combined sitemapPath + sitemapVersion
            EwsWrapper.Instance().Create(family, activityData.ProductName, activityData.Ipv4Address, Path.Combine(activityData.SitemapPath, activityData.SiteMapVersion), BrowserModel.Firefox);

            EwsWrapper.Instance().Start();
            EwsWrapper.Instance().WakeUpPrinter();
            EwsWrapper.Instance().SetAdvancedOptions();
            EwsWrapper.Instance().EnableSnmpv1v2ReadWriteAccess();

            SnmpWrapper.Instance().Create(activityData.Ipv4Address);
            SnmpWrapper.Instance().SetCommunityName("public");

            TelnetWrapper.Instance().Create(activityData.Ipv4Address);

            //  PrinterFamilies family = (PrinterFamilies)Enum.Parse(typeof(PrinterFamilies), Enum<ProductFamilies>.Value(activityData.ProductFamily));
            Printer.Printer printer = PrinterFactory.Create(family, ipV4Address);
            activityData.MacAddress = printer.MacAddress;

            //Check the Windows Server Service,Packet Capture service and Kiwi Syslog server is up and running
            CtcUtility.StartService("WindowsServerService", activityData.DhcpServerIp);
            CtcUtility.StartService(@"dns", activityData.DhcpServerIp);

            using (DhcpApplicationServiceClient dhcpClient = DhcpApplicationServiceClient.Create(activityData.DhcpServerIp))
            {
                string scope = dhcpClient.Channel.GetDhcpScopeIP(activityData.DhcpServerIp);
                dhcpClient.Channel.DeleteReservation(activityData.DhcpServerIp, scope, activityData.Ipv4Address, activityData.MacAddress);

                if (dhcpClient.Channel.CreateReservation(activityData.DhcpServerIp, scope, ipV4Address.ToString(), activityData.MacAddress, ReservationType.Both))
                {
                    TraceFactory.Logger.Info("Successfully created reservation for IP address: {0}, Mac address: {1} for {2}".FormatWith(ipV4Address, activityData.MacAddress, ReservationType.Both));
                }
                else
                {
                    TraceFactory.Logger.Info("Failed to create reservation for IP address: {0}, Mac address: {1} for {2}".FormatWith(ipV4Address, activityData.MacAddress, ReservationType.Both));
                    return(new PluginExecutionResult(PluginResult.Failed, "Failed to create reservation for IP address: {0}, Mac address: {1} for {2}".FormatWith(ipV4Address, activityData.MacAddress, ReservationType.Both)));
                }
            }

            if (null == _tests)
            {
                _tests = new CertificateManagementTests(activityData);
            }

            // Execute the selected tests
            foreach (int testNumber in activityData.SelectedTests)
            {
                try
                {
                    ExecutionServices.SessionRuntime.AsInternal().WaitIfPaused();
                    _tests.RunTest(executionData, testNumber, ipV4Address, activityData.ProductFamily);
                }
                catch (Exception ex)
                {
                    TraceFactory.Logger.Fatal("** Error while executing Test:{0} \n".FormatWith(testNumber, ex.Message));
                    continue;
                }
            }

            EwsWrapper.Instance().Stop();

            return(new PluginExecutionResult(PluginResult.Passed));
        }
        public PluginExecutionResult Execute(PluginExecutionData executionData)
        {
            CtcSettings.Initialize(executionData);

            NetworkNamingServiceActivityData activityData = executionData.GetMetadata <NetworkNamingServiceActivityData>(CtcMetadataConverter.Converters);

            #region Scenario Prerequisites

            //Check the Windows Server Service,Packet Capture service and Kiwi Syslog server is up and running
            CtcUtility.StartService("WindowsServerService", activityData.PrimaryDhcpServerIPAddress);
            CtcUtility.StartService("PacketCaptureService", activityData.PrimaryDhcpServerIPAddress);
            CtcUtility.StartService("Kiwi Syslog Server", activityData.PrimaryDhcpServerIPAddress);

            //Check dns and wins server is up and running on both primary and secondary dhcp server
            CtcUtility.StartService(@"dns", activityData.PrimaryDhcpServerIPAddress);
            CtcUtility.StartService("WINS", activityData.PrimaryDhcpServerIPAddress);
            CtcUtility.StartService(@"dns", activityData.SecondDhcpServerIPAddress);
            CtcUtility.StartService("WINS", activityData.SecondDhcpServerIPAddress);

            //Check the Wireless printer ip is accessible
            if (activityData.SelectedTests.Contains(678968))
            {
                if (!(NetworkUtil.PingUntilTimeout(IPAddress.Parse(activityData.WirelessIPv4Address), TimeSpan.FromSeconds(20))))
                {
                    MessageBox.Show(string.Concat("Wireless Printer IP Address is not accessible\n\n"),
                                    "Wireless IP Address Not Accessible", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return(new PluginExecutionResult(PluginResult.Failed, "Wireless Printer IP Address is not accessible"));
                }
            }

            //Check whether all devices are accesible and the server IP
            CtcUtility.CheckPrinterConnectivity(activityData.WiredIPv4Address, activityData.PrimaryDhcpServerIPAddress,
                                                activityData.SecondPrinterIPAddress, activityData.SecondDhcpServerIPAddress,
                                                activityData.LinuxServerIPAddress, activityData.SwitchIpAddress);

            // Fetch the VLAN details.
            GetVlanDetails(ref activityData);

            // Check if Switch VLAN details are fetched
            if (3 != activityData.VirtualLanDetails.Count)
            {
                MessageBox.Show(string.Concat("Unable to fetch Switch VLAN details\n\n",
                                              "Check whether Printer is connected to Network Switch.\n",
                                              "Switch should be configured with 3 network virtual LAN."),
                                "Network switch not found", MessageBoxButtons.OK, MessageBoxIcon.Error);

                return(new PluginExecutionResult(PluginResult.Failed, "Unable to fetch Switch VLAN details"));
            }

            //Reservation for Primary Printer
            using (DhcpApplicationServiceClient client = DhcpApplicationServiceClient.Create(activityData.PrimaryDhcpServerIPAddress))
            {
                Printer.Printer printer = PrinterFactory.Create(activityData.ProductFamily, activityData.WiredIPv4Address);
                activityData.PrinterMacAddress = printer.MacAddress.Replace(":", string.Empty);
                client.Channel.DeleteReservation(activityData.PrimaryDhcpServerIPAddress, client.Channel.GetDhcpScopeIP(activityData.PrimaryDhcpServerIPAddress),
                                                 activityData.WiredIPv4Address, activityData.PrinterMacAddress);

                if (client.Channel.CreateReservation(activityData.PrimaryDhcpServerIPAddress, client.Channel.GetDhcpScopeIP(activityData.PrimaryDhcpServerIPAddress),
                                                     activityData.WiredIPv4Address, activityData.PrinterMacAddress, ReservationType.Both))
                {
                    TraceFactory.Logger.Info("Primary Printer IP Address Reservation in DHCP Server for both DHCP and BOOTP : Succeeded");
                }
                else
                {
                    TraceFactory.Logger.Info("Primary Printer IP Address Reservation in DHCP Server for both DHCP and BOOTP: Failed");
                    return(new PluginExecutionResult(PluginResult.Failed, "Primary Printer IP Address Reservation in DHCP Server for both DHCP and BOOTP: Failed"));
                }

                activityData.PrimaryDhcpIPv6Address = client.Channel.GetIPv6Address();
            }

            //Reservation for Secondary Printer[user may give input as primary server ip/secondary server ip ,so getting server ip based on the printer ipaddress]
            string secondDhcpServerIPAddress = Printer.Printer.GetDHCPServerIP(IPAddress.Parse(activityData.SecondPrinterIPAddress)).ToString();
            using (DhcpApplicationServiceClient client = DhcpApplicationServiceClient.Create(secondDhcpServerIPAddress))
            {
                Printer.Printer printer = PrinterFactory.Create(activityData.ProductFamily, activityData.SecondPrinterIPAddress);
                string          secondPrinterMacAddress = printer.MacAddress.Replace(":", string.Empty);
                client.Channel.DeleteReservation(secondDhcpServerIPAddress, client.Channel.GetDhcpScopeIP(secondDhcpServerIPAddress),
                                                 activityData.SecondPrinterIPAddress, secondPrinterMacAddress);

                if (client.Channel.CreateReservation(secondDhcpServerIPAddress, client.Channel.GetDhcpScopeIP(secondDhcpServerIPAddress),
                                                     activityData.SecondPrinterIPAddress, secondPrinterMacAddress, ReservationType.Both))
                {
                    TraceFactory.Logger.Info("Secondary Printer IP Address Reservation in DHCP Server for both DHCP and BOOTP : Succeeded");
                }
                else
                {
                    TraceFactory.Logger.Info("Secondary Printer IP Address Reservation in DHCP Server for both DHCP and BOOTP: Failed");
                    return(new PluginExecutionResult(PluginResult.Failed, "Secondary Printer IP Address Reservation in DHCP Server for both DHCP and BOOTP: Failed"));
                }
            }

            using (DhcpApplicationServiceClient client = DhcpApplicationServiceClient.Create(activityData.SecondDhcpServerIPAddress))
            {
                activityData.SecondaryDhcpIPv6Address = client.Channel.GetIPv6Address();
            }

            #endregion

            // create instance of ews adapter
            EwsWrapper.Instance().Create(Enum <PrinterFamilies> .Parse(activityData.ProductFamily), activityData.ProductName, activityData.WiredIPv4Address, Path.Combine(activityData.SitemapPath, activityData.SiteMapVersion), BrowserModel.Firefox);

            EwsWrapper.Instance().Start();
            EwsWrapper.Instance().WakeUpPrinter();
            EwsWrapper.Instance().SetAdvancedOptions();

            //create instance of SNMP wrapper
            SnmpWrapper.Instance().Create(activityData.WiredIPv4Address);

            //create instance of Telnet wrapper
            TelnetWrapper.Instance().Create(activityData.WiredIPv4Address);

            //Enabling IPV6 startup
            EwsWrapper.Instance().SetDHCPv6OnStartup(true);
            EwsWrapper.Instance().SetIPv6(false);
            EwsWrapper.Instance().SetIPv6(true);
            EwsWrapper.Instance().EnableSnmpv1v2ReadWriteAccess();

            if (null == _networkNamingTests)
            {
                _networkNamingTests = new NetworkNamingServiceTests(activityData);
            }

            // assign the session id to activity data
            activityData.SessionId = executionData.SessionId;

            foreach (int testNumber in activityData.SelectedTests)
            {
                try
                {
                    ExecutionServices.SessionRuntime.AsInternal().WaitIfPaused();
                    _networkNamingTests.RunTest(executionData, testNumber, IPAddress.Parse(activityData.WiredIPv4Address), (ProductFamilies)Enum.Parse(typeof(ProductFamilies), activityData.ProductFamily));
                }
                catch (Exception generalException)
                {
                    TraceFactory.Logger.Info("Test {0} failed with error: {1}".FormatWith(testNumber, generalException.Message));
                }
            }

            EwsWrapper.Instance().Stop();

            return(new PluginExecutionResult(PluginResult.Passed));
        }
        public PluginExecutionResult Execute(PluginExecutionData executionData)
        {
            CtcSettings.Initialize(executionData);

            // create activity data
            IPSecurityActivityData activityData = executionData.GetMetadata <IPSecurityActivityData>(CtcMetadataConverter.Converters);

            #region Scenario Prerequisites

            // TODO: Need to enable broadcast and multicast option in failsafe
            // TODO: Cleaning up the rules on client side and on the printer


            //Check the Windows Server Service,Packet Capture service and Kiwi Sys log server is up and running
            CtcUtility.StartService("WindowsServerService", activityData.PrimaryDhcpServerIPAddress);
            CtcUtility.StartService("PacketCaptureService", activityData.PrimaryDhcpServerIPAddress);

            Printer.Printer printer = PrinterFactory.Create(activityData.ProductFamily, activityData.WiredIPv4Address);
            //Reservation for Primary Printer
            using (DhcpApplicationServiceClient client = DhcpApplicationServiceClient.Create(activityData.PrimaryDhcpServerIPAddress))
            {
                activityData.PrinterMacAddress = printer.MacAddress.Replace(":", string.Empty);
                client.Channel.DeleteReservation(activityData.PrimaryDhcpServerIPAddress, client.Channel.GetDhcpScopeIP(activityData.PrimaryDhcpServerIPAddress),
                                                 activityData.WiredIPv4Address, activityData.PrinterMacAddress);

                if (client.Channel.CreateReservation(activityData.PrimaryDhcpServerIPAddress, client.Channel.GetDhcpScopeIP(activityData.PrimaryDhcpServerIPAddress),
                                                     activityData.WiredIPv4Address, activityData.PrinterMacAddress, ReservationType.Both))
                {
                    TraceFactory.Logger.Info("Primary Printer IP Address Reservation in DHCP Server for both DHCP and BOOTP : Succeeded");
                }
                else
                {
                    TraceFactory.Logger.Info("Primary Printer IP Address Reservation in DHCP Server for both DHCP and BOOTP: Failed");
                    return(new PluginExecutionResult(PluginResult.Failed, "Primary Printer IP Address Reservation in DHCP Server for both DHCP and BOOTP: Failed"));
                }
            }

            #endregion

            // create instance of EWS adapter
            EwsWrapper.Instance().Create(Enum <PrinterFamilies> .Parse(activityData.ProductFamily), activityData.ProductName, activityData.WiredIPv4Address, Path.Combine(activityData.SitemapPath, activityData.SitemapsVersion), BrowserModel.Firefox, EwsAdapterType.WebDriverAdapter);

            EwsWrapper.Instance().Start();
            EwsWrapper.Instance().WakeUpPrinter();

            //create instance of SNMP wrapper
            SnmpWrapper.Instance().Create(activityData.WiredIPv4Address);

            //create instance of Telnet wrapper
            TelnetWrapper.Instance().Create(activityData.WiredIPv4Address);

            //IPv6 and Dhcpv6 on startup should be enabled to get IPv6 addresses. Applicable only for VEP
            if (PrinterFamilies.VEP.ToString().EqualsIgnoreCase(activityData.ProductFamily) ||
                PrinterFamilies.LFP.ToString().EqualsIgnoreCase(activityData.ProductFamily))
            {
                EwsWrapper.Instance().SetDHCPv6(true);
                EwsWrapper.Instance().SetDHCPv6OnStartup(true);
                EwsWrapper.Instance().SetIPv6(false);
                EwsWrapper.Instance().SetIPv6(true);
                EwsWrapper.Instance().EnableSnmpv1v2ReadWriteAccess();
            }

            TraceFactory.Logger.Info("Collecting Ipv6 addresses of the printer");
            activityData.IPV6StatefullAddress = printer.IPv6StateFullAddress.ToString();
            activityData.IPV6StatelessAddress = printer.IPv6StatelessAddresses[0].ToString();
            activityData.LinkLocalAddress     = printer.IPv6LinkLocalAddress.ToString();

            // assign session id to activity data
            activityData.SessionId = executionData.SessionId;

            if (null == _ipSecuritytests)
            {
                _ipSecuritytests = new IPSecurityTests(activityData);
            }

            // Execute the selected tests
            foreach (int testNumber in activityData.SelectedTests)
            {
                try
                {
                    ExecutionServices.SessionRuntime.AsInternal().WaitIfPaused();
                    _ipSecuritytests.RunTest(executionData, testNumber, IPAddress.Parse(activityData.WiredIPv4Address), (ProductFamilies)Enum.Parse(typeof(ProductFamilies), activityData.ProductFamily));
                }
                catch (Exception ex)
                {
                    TraceFactory.Logger.Fatal("Error while executing Test:{0} \n".FormatWith(testNumber, ex.Message));
                    continue;
                }
            }

            EwsWrapper.Instance().Stop();

            return(new PluginExecutionResult(PluginResult.Passed));
        }
예제 #9
0
        public PluginExecutionResult Execute(PluginExecutionData executionData)
        {
            CtcSettings.Initialize(executionData);

            ConnectivityPrintActivityData activityData = executionData.GetMetadata <ConnectivityPrintActivityData>(CtcMetadataConverter.Converters);
            PrinterFamilies family = (PrinterFamilies)Enum.Parse(typeof(PrinterFamilies), Enum <ProductFamilies> .Value(activityData.ProductFamily));

            Printer.Printer printer = PrinterFactory.Create(family, IPAddress.Parse(activityData.Ipv4Address));

            if (!NetworkUtil.PingUntilTimeout(IPAddress.Parse(activityData.Ipv4Address), TimeSpan.FromSeconds(10)))
            {
                MessageBox.Show(string.Concat("Printer IPv4 Address is not accessible\n\n",
                                              "IPv4 address: {0}\n".FormatWith(activityData.Ipv4Address)),
                                @"IPv4 Address Not Accessible", MessageBoxButtons.OK, MessageBoxIcon.Error);

                return(new PluginExecutionResult(PluginResult.Failed, "Printer IPv4 Address is not accessible"));
            }

            // create instance of ews adapter
            EwsWrapper.Instance().Create(family, activityData.ProductName, activityData.Ipv4Address, Path.Combine(activityData.SitemapPath, activityData.SiteMapVersion), BrowserModel.Firefox);
            EwsWrapper.Instance().Start();
            EwsWrapper.Instance().WakeUpPrinter();
            EwsWrapper.Instance().SetAdvancedOptions();
            EwsWrapper.Instance().EnableSnmpv1v2ReadWriteAccess();

            //Enabling IPV6 startup
            EwsWrapper.Instance().SetDHCPv6OnStartup(true);
            EwsWrapper.Instance().SetIPv6(false);
            EwsWrapper.Instance().SetIPv6(true);

            // If printer is not available, assign default IPAddress
            if (printer.PingUntilTimeout(IPAddress.Parse(activityData.Ipv4Address), 1))
            {
                // Get All Ipv6 Addresses
                activityData.Ipv6LinkLocalAddress = printer.IPv6LinkLocalAddress?.ToString() ?? string.Empty;
                activityData.Ipv6StateFullAddress = printer.IPv6StateFullAddress?.ToString() ?? string.Empty;
                activityData.Ipv6StatelessAddress = printer.IPv6StatelessAddresses.Count == 0 ? string.Empty : printer.IPv6StatelessAddresses[0].ToString();
            }
            else
            {
                activityData.Ipv6LinkLocalAddress = string.Empty;
                activityData.Ipv6StateFullAddress = string.Empty;
                activityData.Ipv6StatelessAddress = string.Empty;
            }

            foreach (Ipv6AddressTypes addressType in activityData.Ipv6AddressTypes)
            {
                if (Ipv6AddressTypes.LinkLocal == addressType)
                {
                    if (!NetworkUtil.PingUntilTimeout(IPAddress.Parse(activityData.Ipv6LinkLocalAddress), TimeSpan.FromSeconds(10)))
                    {
                        MessageBox.Show(string.Concat("Printer Link Local Address is not accessible\n\n",
                                                      "Link local address: {0}\n".FormatWith(activityData.Ipv6LinkLocalAddress),
                                                      "Check if Stateless and Stateful address are pinging if you have selected it.\n",
                                                      "Stateless: {0}, Stateful: {1}".FormatWith(activityData.Ipv6StatelessAddress, activityData.Ipv6StateFullAddress)),
                                        @"Link Local Address Not Accessible", MessageBoxButtons.OK, MessageBoxIcon.Error);

                        return(new PluginExecutionResult(PluginResult.Failed, "Printer Link Local Address is not accessible"));
                    }
                }
                else if (Ipv6AddressTypes.Stateless == addressType)
                {
                    if (!NetworkUtil.PingUntilTimeout(IPAddress.Parse(activityData.Ipv6StatelessAddress), TimeSpan.FromSeconds(10)))
                    {
                        MessageBox.Show(string.Concat("Printer Stateless Address is not accessible\n\n",
                                                      "Stateless address: {0}\n".FormatWith(activityData.Ipv6StatelessAddress),
                                                      "Check if Stateful address is pinging if you have selected it.\n",
                                                      "Stateful: {0}".FormatWith(activityData.Ipv6StateFullAddress)),
                                        @"Stateless Address Not Accessible", MessageBoxButtons.OK, MessageBoxIcon.Error);

                        return(new PluginExecutionResult(PluginResult.Failed, "Printer Stateless Address is not accessible"));
                    }
                }
                else if (Ipv6AddressTypes.Stateful == addressType)
                {
                    if (!NetworkUtil.PingUntilTimeout(IPAddress.Parse(activityData.Ipv6StateFullAddress), TimeSpan.FromSeconds(10)))
                    {
                        MessageBox.Show(string.Concat("Printer Stateful Address is not accessible\n\n",
                                                      "Stateful address: {0}\n".FormatWith(activityData.Ipv6StateFullAddress)),
                                        @"Stateful Address Not Accessible", MessageBoxButtons.OK, MessageBoxIcon.Error);

                        return(new PluginExecutionResult(PluginResult.Failed, "Printer Stateful Address is not accessible"));
                    }
                }
            }

            //Reservation for Primary Printer
            string value    = activityData.Ipv4Address.Split(new char[] { '.' })[2];
            string serverIp = DHCP_SERVER_IP_FORMAT.FormatWith(value);

            TraceFactory.Logger.Info("Server IP : {0}".FormatWith(serverIp));
            //string serverIp = Printer.Printer.GetDHCPServerIP(IPAddress.Parse(activityData.Ipv4Address)).ToString();
            string printerMacAddress = printer.MacAddress.Replace(":", string.Empty);

            using (DhcpApplicationServiceClient client = DhcpApplicationServiceClient.Create(serverIp))
            {
                string scope = client.Channel.GetDhcpScopeIP(serverIp);
                TraceFactory.Logger.Info("Scope : {0}".FormatWith(scope));
                client.Channel.DeleteReservation(serverIp, client.Channel.GetDhcpScopeIP(serverIp), activityData.Ipv4Address, printerMacAddress);

                if (client.Channel.CreateReservation(serverIp, client.Channel.GetDhcpScopeIP(serverIp), activityData.Ipv4Address, printerMacAddress, ReservationType.Both))
                {
                    TraceFactory.Logger.Info("Primary Printer IP Address Reservation in DHCP Server for both DHCP and BOOTP : Succeeded");
                }
                else
                {
                    TraceFactory.Logger.Info("Primary Printer IP Address Reservation in DHCP Server for both DHCP and BOOTP: Failed");
                    return(new PluginExecutionResult(PluginResult.Failed, "Primary Printer IP Address Reservation in DHCP Server for both DHCP and BOOTP: Failed"));
                }
            }

            EwsWrapper.Instance().SetAdvancedOptions();

            string documentsPath      = activityData.DocumentsPath;
            string documentsSharePath = Path.Combine(CtcSettings.ConnectivityShare, activityData.ProductFamily.ToString());

            // Combine the connectivity share path with the selected document
            // In case of Re-run, path is already constructed. Hence do not construct it again.
            if (!Directory.Exists(documentsPath))
            {
                if (!documentsPath.StartsWith(documentsSharePath, StringComparison.CurrentCulture))
                {
                    documentsPath = Path.Combine(documentsSharePath, activityData.DocumentsPath, ConnectivityPrintConfigurationControl.DIRECTORY_DOCUMENTS);

                    activityData.DocumentsPath = documentsPath;
                }
            }

            if (activityData.IsWspTestsSelected)
            {
                printer.NotifyWSPrinter += printer_NotifyWSPAddition;
                if (printer.Install(IPAddress.Parse(activityData.Ipv4Address), Printer.Printer.PrintProtocol.WSP, activityData.DriverPackagePath, activityData.DriverModel))
                {
                    MessageBox.Show(@"WS Printer was added successfully.", @"WS Printer Successful", MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
                else
                {
                    MessageBox.Show(@"WS Printer was not added successfully. All WS Print related tests will fail.", @"WS Printer Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }

            if (null == _printTests)
            {
                _printTests = new ConnectivityPrintTests(activityData);
            }

            foreach (int testNumber in activityData.SelectedTests)
            {
                ExecutionServices.SessionRuntime.AsInternal().WaitIfPaused();
                _printTests.RunTest(executionData, testNumber, IPAddress.Parse(activityData.Ipv4Address), activityData.ProductFamily);
            }

            return(new PluginExecutionResult(PluginResult.Passed));
        }
        public PluginExecutionResult Execute(PluginExecutionData executionData)
        {
            // create activity data
            IPConfigurationActivityData activityData = executionData.GetMetadata <IPConfigurationActivityData>();

            // Check if printer is accessible

            if (!(NetworkUtil.PingUntilTimeout(IPAddress.Parse(activityData.PrimaryWiredIPv4Address), TimeSpan.FromSeconds(20))) &&
                Utility.IsClientConfiguredWithServerIP(activityData.SecondDhcpServerIPAddress, activityData.LinuxServerIPAddress))
            {
                MessageBox.Show(string.Concat("Printer IP Address is not accessible or Client is not configured with Server IP Address.\n\n",
                                              "Make sure you have provided valid Printer IP Address and is accessible.\n",
                                              "Check if Client has acquired IPv4 Address from Secondary DHCP Server.\n",
                                              "Check if Client has acquired IPv4 Address from Linux Server."),
                                "IP Address Not Accessible", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return(new PluginExecutionResult(PluginResult.Failed, "Printer IP Address is not accessible or Client is not configured with Server IP Address."));
            }

            // Check if the required services are running on DHCP server
            if (!IsServicesRunning(activityData.PrimaryDhcpServerIPAddress, activityData.SecondDhcpServerIPAddress))
            {
                return(new PluginExecutionResult(PluginResult.Failed, "Services are not running on DHCP server."));
            }

            // create instance of ews adapter
            EwsWrapper.Instance().Create(activityData.ProductFamily, activityData.ProductName, activityData.PrimaryWiredIPv4Address, activityData.SitemapsVersion,
                                         BrowserModel.Firefox, EwsAdapterType.WebDriverAdapter);

            EwsWrapper.Instance().Start();


            EwsWrapper.Instance().WakeUpPrinter();
            EwsWrapper.Instance().SetAdvancedOptions();

            IPAddress secondaryAddress = null;

            if (IPAddress.TryParse(activityData.SecondaryWiredIPv4Address, out secondaryAddress))
            {
                EwsWrapper.Instance().ChangeDeviceAddress(secondaryAddress);
                EwsWrapper.Instance().SetAdvancedOptions();
            }

            if (IPAddress.TryParse(activityData.WirelessIPv4Address, out secondaryAddress))
            {
                EwsWrapper.Instance().ChangeDeviceAddress(secondaryAddress);
                EwsWrapper.Instance().SetAdvancedOptions();
            }

            EwsWrapper.Instance().ChangeDeviceAddress(activityData.PrimaryWiredIPv4Address);

            Printer.Printer printer = PrinterFactory.Create(activityData.ProductFamily, activityData.PrimaryWiredIPv4Address);

            try
            {
                activityData.PrimaryMacAddress = printer.MacAddress.Replace(":", string.Empty);
            }
            catch
            { }

            if (string.IsNullOrEmpty(activityData.PrimaryMacAddress))
            {
                TraceFactory.Logger.Info("Could not get the mac address for Secondary wired interface.");
                return(new PluginExecutionResult(PluginResult.Failed, "Could not get the mac address for Secondary wired interface."));
            }

            if (activityData.PrinterInterfaceType == CtcBase.Controls.InterfaceType.Single)
            {
                if (IPAddress.TryParse(activityData.SecondaryWiredIPv4Address, out secondaryAddress))
                {
                    try
                    {
                        printer = PrinterFactory.Create(activityData.ProductFamily, activityData.SecondaryWiredIPv4Address);
                        activityData.SecondaryMacAddress = printer.MacAddress;
                    }
                    catch { }

                    if (string.IsNullOrEmpty(activityData.SecondaryMacAddress))
                    {
                        TraceFactory.Logger.Info("Could not get the mac address for Secondary wired interface.");
                        return(new PluginExecutionResult(PluginResult.Failed, "Could not get the mac address for Secondary wired interface."));
                    }
                }

                if (IPAddress.TryParse(activityData.WirelessIPv4Address, out secondaryAddress))
                {
                    try
                    {
                        printer = PrinterFactory.Create(activityData.ProductFamily, activityData.WirelessIPv4Address);
                        activityData.WirelessMacAddress = printer.MacAddress;
                    }catch { }

                    if (string.IsNullOrEmpty(activityData.WirelessMacAddress))
                    {
                        TraceFactory.Logger.Info("Could not get the mac address for Secondary wired interface.");
                        return(new PluginExecutionResult(PluginResult.Failed, "Could not get the mac address for wireless interface."));
                    }
                }
            }

            DhcpApplicationServiceClient serviceFunction = DhcpApplicationServiceClient.Create(activityData.PrimaryDhcpServerIPAddress);

            activityData.DHCPScopeIPAddress        = serviceFunction.Channel.GetDhcpScopeIP(activityData.PrimaryDhcpServerIPAddress);
            activityData.ServerDNSPrimaryIPAddress = serviceFunction.Channel.GetPrimaryDnsServer(activityData.PrimaryDhcpServerIPAddress, activityData.DHCPScopeIPAddress);
            activityData.SecondaryDnsIPAddress     = serviceFunction.Channel.GetSecondaryDnsServer(activityData.PrimaryDhcpServerIPAddress, activityData.DHCPScopeIPAddress);
            activityData.ServerHostName            = serviceFunction.Channel.GetHostName(activityData.PrimaryDhcpServerIPAddress, activityData.DHCPScopeIPAddress);
            activityData.DomainName            = serviceFunction.Channel.GetDomainName(activityData.PrimaryDhcpServerIPAddress, activityData.DHCPScopeIPAddress);
            activityData.ServerRouterIPAddress = serviceFunction.Channel.GetRouterAddress(activityData.PrimaryDhcpServerIPAddress, activityData.DHCPScopeIPAddress);
            activityData.ServerDNSSuffix       = serviceFunction.Channel.GetDnsSuffix(activityData.PrimaryDhcpServerIPAddress, activityData.DHCPScopeIPAddress);

            string ipv6Scope = serviceFunction.Channel.GetIPv6Scope(activityData.PrimaryDhcpServerIPAddress);

            if (string.IsNullOrEmpty(ipv6Scope))
            {
                MessageBox.Show(string.Concat("Unable to fetch IPv6 Scope \n\n",
                                              "Check whether DHCP IPv6 Scope is configured on DHCP server."),
                                "IPv6 Scope Not found", MessageBoxButtons.OK, MessageBoxIcon.Error);

                return(new PluginExecutionResult(PluginResult.Failed, "Check whether DHCP IPv6 Scope is configured on DHCP server."));
            }

            activityData.DHCPScopeIPv6Address = serviceFunction.Channel.GetIPv6Scope(activityData.PrimaryDhcpServerIPAddress);

            // Fetch the VLAN details.
            GetVlanDetails(ref activityData);

            // Check if Switch VLAN details are fetched
            if (3 != activityData.VirtualLanDetails.Count)
            {
                MessageBox.Show(string.Concat("Unable to fetch Switch VLAN details\n\n",
                                              "Check whether Printer is connected to Network Switch.\n",
                                              "Switch should be configured with 3 network virtual LAN."),
                                "Network switch not found", MessageBoxButtons.OK, MessageBoxIcon.Error);

                return(new PluginExecutionResult(PluginResult.Failed, "Unable to fetch Switch VLAN details. Check whether Printer is connected to Network Switch. Switch should be configured with 3 network virtual LAN."));
            }

            // Router Details: Address, Id, IPv6 Addresses
            IRouter router = null;

            activityData.RouterAddress = ROUTER_IP_FORMAT.FormatWith(activityData.PrimaryWiredIPv4Address.Substring(0, activityData.PrimaryWiredIPv4Address.LastIndexOf(".", StringComparison.CurrentCultureIgnoreCase)));
            router = RouterFactory.Create(IPAddress.Parse(activityData.RouterAddress), ROUTER_USERNAME, ROUTER_PASSWORD);

            Dictionary <int, IPAddress> routerVlans = router.GetAvailableVirtualLans();

            activityData.RouterVlanId = routerVlans.Where(x => (null != x.Value) && (x.Value.IsInSameSubnet(IPAddress.Parse(activityData.RouterAddress)))).FirstOrDefault().Key;

            RouterVirtualLAN       routerVlan          = router.GetVirtualLanDetails(activityData.RouterVlanId);
            Collection <IPAddress> routerIPv6Addresses = router.GetIPv6Addresses(routerVlan.IPv6Details);

            activityData.RouterIPv6Addresses = new Collection <string>(routerIPv6Addresses.Select(x => x.ToString()).ToList());

            // Add source IP Address
            Utility.AddSourceIPAddress(activityData.PrimaryDhcpServerIPAddress, activityData.LinuxServerIPAddress);

            //create instance of SNMP wrapper
            SnmpWrapper.Instance().Create(activityData.PrimaryWiredIPv4Address);

            //create instance of Telnet wrapper
            TelnetWrapper.Instance().Create(activityData.PrimaryWiredIPv4Address);

            if (!ManageReservation(activityData))
            {
                return(new PluginExecutionResult(PluginResult.Failed, "Printer IP Address Reservation in DHCP Server for both DHCP and BOOTP: Failed"));
            }

            TraceFactory.Logger.Info("The Server Configured Value retrieved from the DHCP Server are as follows:");
            TraceFactory.Logger.Info("MacAddress:{0}, DNSPrimaryIP:{1}, HostName:{2}, RouterIP:{3}, DNSSuffix:{4}".FormatWith(activityData.PrimaryMacAddress, activityData.ServerDNSPrimaryIPAddress,
                                                                                                                              activityData.ServerHostName, activityData.ServerRouterIPAddress, activityData.ServerDNSSuffix));

            // assign the session id to activity id
            activityData.SessionId = executionData.SessionId;

            if (null == _ipConfigTests)
            {
                _ipConfigTests = new IPConfigurationTests(activityData);
            }

            foreach (int testNumber in activityData.SelectedTests)
            {
                try
                {
                    ApplicationFlowControl.Instance.CheckWait(LogPauseState, LogResumeState);
                    _ipConfigTests.RunTest(executionData, testNumber, activityData.PrimaryWiredIPv4Address, (ProductFamilies)Enum.Parse(typeof(ProductFamilies), activityData.ProductFamily));
                }
                catch (Exception generalException)
                {
                    TraceFactory.Logger.Info("Test {0} failed with error: {1}".FormatWith(testNumber, generalException.Message));
                }
            }

            EwsWrapper.Instance().Stop();

            return(new PluginExecutionResult(PluginResult.Passed));
        }
예제 #11
0
        public PluginExecutionResult Execute(PluginExecutionData executionData)
        {
            CtcSettings.Initialize(executionData);

            // create activity data
            SecurityActivityData activityData = executionData.GetMetadata <SecurityActivityData>(CtcMetadataConverter.Converters);

            Printer.Printer printer = PrinterFactory.Create(activityData.ProductFamily, activityData.WiredIPv4Address);
            activityData.WiredMacAddress = printer.MacAddress;

            TraceFactory.Logger.Info("Wired Mac Address: {0}".FormatWith(activityData.WiredMacAddress));

            if (activityData.ProductFamily.EqualsIgnoreCase(PrinterFamilies.VEP.ToString()))
            {
                IPAddress ipAddress;

                if (IPAddress.TryParse(activityData.SecondaryWiredIPv4Address, out ipAddress))
                {
                    printer = PrinterFactory.Create(activityData.ProductFamily, activityData.SecondaryWiredIPv4Address);
                    activityData.SecondaryWiredMacAddress = printer.MacAddress;
                    TraceFactory.Logger.Info("Secondary Wired Mac Address: {0}".FormatWith(activityData.SecondaryWiredMacAddress));
                }

                if (IPAddress.TryParse(activityData.WirelessIPv4Address, out ipAddress))
                {
                    printer = PrinterFactory.Create(activityData.ProductFamily, activityData.WirelessIPv4Address);
                    activityData.WirelessMacAddress = printer.MacAddress;

                    TraceFactory.Logger.Info("Wireless Mac Address: {0}".FormatWith(activityData.WirelessMacAddress));
                }
            }

            List <NetworkInterface> clientNetworks = NetworkInterface.GetAllNetworkInterfaces().Where(n => n.OperationalStatus == OperationalStatus.Up).ToList();
            List <IPAddress>        localAddresses = NetworkUtil.GetLocalAddresses().Where(x => x.AddressFamily == AddressFamily.InterNetwork).ToList();

            EwsWrapper.Instance().Create(Enum <PrinterFamilies> .Parse(activityData.ProductFamily), activityData.ProductName, activityData.WiredIPv4Address, Path.Combine(activityData.SitemapPath, activityData.SitemapsVersion), BrowserModel.Firefox);
            EwsWrapper.Instance().Start();
            EwsWrapper.Instance().EnableSnmpv1v2ReadWriteAccess();

            if (!SecurityScenarioPrerequisites(activityData, clientNetworks, localAddresses))
            {
                return(new PluginExecutionResult(PluginResult.Failed, "Failed in Scenario pre-requisites"));
            }
            //create instance of SNMP wrapper
            SnmpWrapper.Instance().Create(activityData.WiredIPv4Address);

            //create instance of Telnet wrapper
            TelnetWrapper.Instance().Create(activityData.WiredIPv4Address);

            if (null == _securitytests)
            {
                _securitytests = new SecurityTests(activityData);
            }

            // Execute the selected tests
            foreach (int testNumber in activityData.SelectedTests)
            {
                try
                {
                    ExecutionServices.SessionRuntime.AsInternal().WaitIfPaused();
                    _securitytests.RunTest(executionData, testNumber, IPAddress.Parse(activityData.WiredIPv4Address), (ProductFamilies)Enum.Parse(typeof(ProductFamilies), activityData.ProductFamily));
                }
                catch (Exception ex)
                {
                    TraceFactory.Logger.Fatal("Error while executing Test:{0} \n".FormatWith(testNumber, ex.Message));
                }
            }

            EwsWrapper.Instance().Stop();
            ManageClientReservation(clientNetworks, localAddresses, activityData, true);

            return(new PluginExecutionResult(PluginResult.Passed));
        }
예제 #12
0
        private bool SecurityScenarioPrerequisites(SecurityActivityData activityData, List <NetworkInterface> clientNetworks, List <IPAddress> localAddresses)
        {
            bool continueTest = true;

            while (continueTest && !NetworkUtil.PingUntilTimeout(IPAddress.Parse(activityData.WiredIPv4Address), TimeSpan.FromSeconds(30)))
            {
                continueTest = SecurityTemplates.ShowErrorPopUp("Printer: {0} is not available.\nPlease cold reset the printer.".FormatWith(activityData.WiredIPv4Address));
            }

            if (activityData.ProductFamily.EqualsIgnoreCase(PrinterFamilies.VEP.ToString()))
            {
                IPAddress ipAddress;

                if (IPAddress.TryParse(activityData.SecondaryWiredIPv4Address, out ipAddress))
                {
                    if (!NetworkUtil.PingUntilTimeout(IPAddress.Parse(activityData.SecondaryWiredIPv4Address), TimeSpan.FromSeconds(10)))
                    {
                        SecurityTemplates.ShowErrorPopUp("The IP address: {0} is not available.\nPlease cold reset the printer.".FormatWith(activityData.SecondaryWiredIPv4Address));
                    }

                    //Utility.StartService(activityData.SecondaryDhcpServerIPAddress, "WindowsServerService");

                    CreateReservation(activityData.SecondaryWiredIPv4Address, activityData.SecondaryDhcpServerIPAddress, activityData.SecondaryWiredMacAddress);

                    EwsWrapper.Instance().ChangeDeviceAddress(activityData.SecondaryWiredIPv4Address);
                    EwsWrapper.Instance().Start();
                    EwsWrapper.Instance().SetAdvancedOptions();
                }

                if (IPAddress.TryParse(activityData.WirelessIPv4Address, out ipAddress))
                {
                    if (!NetworkUtil.PingUntilTimeout(IPAddress.Parse(activityData.WirelessIPv4Address), TimeSpan.FromSeconds(10)))
                    {
                        SecurityTemplates.ShowErrorPopUp("The IP address: {0} is not available.\nPlease cold reset the printer.".FormatWith(activityData.WirelessIPv4Address));
                    }

                    //Utility.StartService(activityData.ThirdDhcpServerIPAddress, "WindowsServerService");

                    CreateReservation(activityData.WirelessIPv4Address, activityData.ThirdDhcpServerIPAddress, activityData.WirelessMacAddress);

                    EwsWrapper.Instance().ChangeDeviceAddress(activityData.WirelessIPv4Address);
                    EwsWrapper.Instance().SetAdvancedOptions();
                }

                EwsWrapper.Instance().ChangeDeviceAddress(activityData.WiredIPv4Address);
            }

            if (!CtcUtility.IsClientConfiguredWithServerIP(activityData.SecondaryDhcpServerIPAddress))
            {
                SecurityTemplates.ShowErrorPopUp("Check if Client has acquired IPv4 Address from Secondary DHCP Server.");
            }

            //Utility.StartService(activityData.PrimaryDhcpServerIPAddress, "WindowsServerService");

            ManageClientReservation(clientNetworks, localAddresses, activityData);

            EwsWrapper.Instance().ChangeDeviceAddress(activityData.WiredIPv4Address);
            EwsWrapper.Instance().SetAdvancedOptions();

            CreateReservation(activityData.WiredIPv4Address, activityData.PrimaryDhcpServerIPAddress, activityData.WiredMacAddress);

            return(true);
        }
        public PluginExecutionResult Execute(PluginExecutionData executionData)
        {
            CtcSettings.Initialize(executionData);

            // Create Activity Data
            IPConfigurationActivityData activityData = executionData.GetMetadata <IPConfigurationActivityData>(CtcMetadataConverter.Converters);

            // Check Printer Accessibility
            if (!(NetworkUtil.PingUntilTimeout(IPAddress.Parse(activityData.WiredIPv4Address), TimeSpan.FromSeconds(20))) &&
                CtcUtility.IsClientConfiguredWithServerIP(activityData.SecondDhcpServerIPAddress, activityData.LinuxServerIPAddress))
            {
                MessageBox.Show(string.Concat("Printer IP Address is not accessible or Client is not configured with Server IP Address.\n\n",
                                              "Make sure you have provided valid Printer IP Address and is accessible.\n",
                                              "Check if Client has acquired IPv4 Address from Secondary DHCP Server.\n",
                                              "Check if Client has acquired IPv4 Address from Linux Server."),
                                @"IP Address Not Accessible", MessageBoxButtons.OK, MessageBoxIcon.Error);
                return(new PluginExecutionResult(PluginResult.Failed, "Printer IP Address is not accessible or Client is not configured with Server IP Address."));
            }

            // Check Services on DHCP Servers
            if (!IsServicesRunning(activityData.PrimaryDhcpServerIPAddress, activityData.SecondDhcpServerIPAddress))
            {
                return(new PluginExecutionResult(PluginResult.Failed, "Services are not running on DHCP server."));
            }

            // Server Configurations

            Printer.Printer printer = PrinterFactory.Create(activityData.ProductFamily, activityData.WiredIPv4Address);
            TraceFactory.Logger.Info("Printer : {0}".FormatWith(printer));
            TraceFactory.Logger.Info("printer.MacAddress :{0}".FormatWith(printer.MacAddress));
            activityData.PrinterMacAddress = printer.MacAddress.Replace(":", string.Empty);
            TraceFactory.Logger.Info("PrinterMacAddress : {0}".FormatWith(activityData.PrinterMacAddress));

            DhcpApplicationServiceClient serviceFunctionPrimaryServer = DhcpApplicationServiceClient.Create(activityData.PrimaryDhcpServerIPAddress);

            activityData.PrimaryDHCPServerIPv6Address = serviceFunctionPrimaryServer.Channel.GetIPv6Address();
            activityData.DHCPScopeIPAddress           = serviceFunctionPrimaryServer.Channel.GetDhcpScopeIP(activityData.PrimaryDhcpServerIPAddress);
            activityData.DHCPScopeIPv6Address         = serviceFunctionPrimaryServer.Channel.GetIPv6Scope(activityData.PrimaryDhcpServerIPAddress);

            DhcpApplicationServiceClient serviceFunctionSecondaryServer = DhcpApplicationServiceClient.Create(activityData.SecondDhcpServerIPAddress);

            activityData.SecondaryDHCPServerIPv6Address = serviceFunctionSecondaryServer.Channel.GetIPv6Address();
            activityData.SecondaryDHCPServerIPv4Scope   = serviceFunctionSecondaryServer.Channel.GetDhcpScopeIP(activityData.SecondDhcpServerIPAddress);
            activityData.SecondaryDHCPServerIPv6Scope   = serviceFunctionSecondaryServer.Channel.GetIPv6Scope(activityData.SecondDhcpServerIPAddress);

            ServerConfiguration(ref activityData);
            DhcpApplicationServiceClient serviceFunction = DhcpApplicationServiceClient.Create(activityData.PrimaryDhcpServerIPAddress);

            activityData.ServerDNSPrimaryIPAddress = serviceFunction.Channel.GetPrimaryDnsServer(activityData.PrimaryDhcpServerIPAddress, activityData.DHCPScopeIPAddress);
            activityData.SecondaryDnsIPAddress     = serviceFunction.Channel.GetSecondaryDnsServer(activityData.PrimaryDhcpServerIPAddress, activityData.DHCPScopeIPAddress);
            activityData.ServerHostName            = serviceFunction.Channel.GetHostName(activityData.PrimaryDhcpServerIPAddress, activityData.DHCPScopeIPAddress);
            activityData.DomainName            = serviceFunction.Channel.GetDomainName(activityData.PrimaryDhcpServerIPAddress, activityData.DHCPScopeIPAddress);
            activityData.ServerRouterIPAddress = serviceFunction.Channel.GetRouterAddress(activityData.PrimaryDhcpServerIPAddress, activityData.DHCPScopeIPAddress);
            activityData.ServerDNSSuffix       = serviceFunction.Channel.GetDnsSuffix(activityData.PrimaryDhcpServerIPAddress, activityData.DHCPScopeIPAddress);

            string ipv6Scope = serviceFunction.Channel.GetIPv6Scope(activityData.PrimaryDhcpServerIPAddress);

            if (string.IsNullOrEmpty(ipv6Scope))
            {
                MessageBox.Show(string.Concat("Unable to fetch IPv6 Scope \n\n",
                                              "Check whether DHCP IPv6 Scope is configured on DHCP server."),
                                @"IPv6 Scope Not found", MessageBoxButtons.OK, MessageBoxIcon.Error);

                return(new PluginExecutionResult(PluginResult.Failed, "Check whether DHCP IPv6 Scope is configured on DHCP server."));
            }

            activityData.DHCPScopeIPv6Address = serviceFunction.Channel.GetIPv6Scope(activityData.PrimaryDhcpServerIPAddress);

            // Fetch and Validate the Switch VLAN details.
            GetVlanDetails(ref activityData);

            if (3 != activityData.VirtualLanDetails.Count)
            {
                MessageBox.Show(string.Concat("Unable to fetch Switch VLAN details\n\n",
                                              "Check whether Printer is connected to Network Switch.\n",
                                              "Switch should be configured with 3 network virtual LAN."),
                                @"Network switch not found", MessageBoxButtons.OK, MessageBoxIcon.Error);

                return(new PluginExecutionResult(PluginResult.Failed, "Unable to fetch Switch VLAN details. Check whether Printer is connected to Network Switch. Switch should be configured with 3 network virtual LAN."));
            }

            // Fetching Router Details
            activityData.RouterIPv4Address = ROUTER_IP_FORMAT.FormatWith(activityData.WiredIPv4Address.Substring(0, activityData.WiredIPv4Address.LastIndexOf(".", StringComparison.CurrentCultureIgnoreCase)));
            var router = RouterFactory.Create(IPAddress.Parse(activityData.RouterIPv4Address), ROUTER_USERNAME, ROUTER_PASSWORD);
            Dictionary <int, IPAddress> routerVlans = router.GetAvailableVirtualLans();

            activityData.RouterVirtualLanId = routerVlans.FirstOrDefault(x => (null != x.Value) && (x.Value.IsInSameSubnet(IPAddress.Parse(activityData.RouterIPv4Address)))).Key;

            RouterVirtualLAN       routerVlan          = router.GetVirtualLanDetails(activityData.RouterVirtualLanId);
            Collection <IPAddress> routerIPv6Addresses = router.GetIPv6Addresses(routerVlan.IPv6Details);

            activityData.RouterIPv6Addresses = new Collection <string>(routerIPv6Addresses.Select(x => x.ToString()).ToList());

            // Add Source IP Address
            CtcUtility.AddSourceIPAddress(activityData.PrimaryDhcpServerIPAddress, activityData.LinuxServerIPAddress);

            // Create Instance of EWS Wrapper
            PrinterFamilies family = (PrinterFamilies)Enum.Parse(typeof(PrinterFamilies), activityData.ProductFamily);

            EwsWrapper.Instance().Create(family, activityData.ProductName, activityData.WiredIPv4Address, Path.Combine(activityData.SitemapPath, activityData.SitemapsVersion), BrowserModel.Firefox);
            EwsWrapper.Instance().Start();
            EwsWrapper.Instance().WakeUpPrinter();
            EwsWrapper.Instance().SetAdvancedOptions();
            EwsWrapper.Instance().SetDefaultIPType(DefaultIPType.AutoIP);
            EwsWrapper.Instance().EnableSnmpv1v2ReadWriteAccess();

            // Create Instance of Telnet Wrapper
            TelnetWrapper.Instance().Create(activityData.WiredIPv4Address);

            // Create Instance of SNMP Wrapper
            SnmpWrapper.Instance().Create(activityData.WiredIPv4Address);

            // Delete Reservation is not validated to handle cases where reservation is not present
            serviceFunction.Channel.DeleteReservation(activityData.PrimaryDhcpServerIPAddress, activityData.DHCPScopeIPAddress, activityData.WiredIPv4Address, activityData.PrinterMacAddress);

            if (serviceFunction.Channel.CreateReservation(activityData.PrimaryDhcpServerIPAddress, activityData.DHCPScopeIPAddress, activityData.WiredIPv4Address, activityData.PrinterMacAddress, ReservationType.Both))
            {
                TraceFactory.Logger.Info("Printer IP Address Reservation in DHCP Server for both DHCP and BOOTP: Succeeded");
            }
            else
            {
                TraceFactory.Logger.Info("Printer IP Address Reservation in DHCP Server for both DHCP and BOOTP: Failed");
                return(new PluginExecutionResult(PluginResult.Failed, "Printer IP Address Reservation in DHCP Server for both DHCP and BOOTP: Failed"));
            }

            TraceFactory.Logger.Info("The Server Configured Value retrieved from the DHCP Server are as follows:");
            TraceFactory.Logger.Info("MacAddress:{0}, DNSPrimaryIP:{1}, HostName:{2}, RouterIP:{3}, DNSSuffix:{4}".FormatWith(activityData.PrinterMacAddress, activityData.ServerDNSPrimaryIPAddress,
                                                                                                                              activityData.ServerHostName, activityData.ServerRouterIPAddress, activityData.ServerDNSSuffix));

            // assign the session id to activity id
            activityData.SessionId = executionData.SessionId;

            if (null == _ipConfigTests)
            {
                _ipConfigTests = new IPConfigurationTests(activityData);
            }

            foreach (int testNumber in activityData.SelectedTests)
            {
                try
                {
                    ExecutionServices.SessionRuntime.AsInternal().WaitIfPaused();
                    _ipConfigTests.RunTest(executionData, testNumber, IPAddress.Parse(activityData.WiredIPv4Address), (ProductFamilies)Enum.Parse(typeof(ProductFamilies), activityData.ProductFamily));
                }
                catch (Exception generalException)
                {
                    TraceFactory.Logger.Info("Test {0} failed with error: {1}".FormatWith(testNumber, generalException.Message));
                }
            }

            EwsWrapper.Instance().Stop();

            return(new PluginExecutionResult(PluginResult.Passed));
        }
예제 #14
0
        public PluginExecutionResult Execute(PluginExecutionData executionData)
        {
            CtcSettings.Initialize(executionData);

            // create activity data
            WirelessActivityData activityData = executionData.GetMetadata <WirelessActivityData>(CtcMetadataConverter.Converters);

            string ipAddress = activityData.ProductFamily == ProductFamilies.VEP && activityData.PrinterInterfaceType == ProductType.MultipleInterface ? activityData.WirelessInterfaceAddress : activityData.PrimaryInterfaceAddress;


            bool continueTest = true;

            if (activityData.ProductFamily == ProductFamilies.VEP)
            {
                while (continueTest && !NetworkUtil.PingUntilTimeout(IPAddress.Parse(activityData.WirelessInterfaceAddress), TimeSpan.FromSeconds(10)))
                {
                    continueTest = CtcUtility.ShowErrorPopup($"Printer: {activityData.WirelessInterfaceAddress} is not available.\n Please cold reset the printer.");
                }
            }

            while (continueTest && !NetworkUtil.PingUntilTimeout(IPAddress.Parse(activityData.PrimaryInterfaceAddress), TimeSpan.FromSeconds(10)))
            {
                continueTest = CtcUtility.ShowErrorPopup($"Printer: {activityData.PrimaryInterfaceAddress} is not available.\n Please cold reset the printer.");
            }

            EwsWrapper.Instance().Create((PrinterFamilies)Enum.Parse(typeof(PrinterFamilies), activityData.ProductFamily.ToString()), activityData.ProductName, ipAddress, Path.Combine(activityData.SitemapPath, activityData.SitemapVersion), BrowserModel.Firefox);

            EwsWrapper.Instance().Start();
            EwsWrapper.Instance().EnableSnmpv1v2ReadWriteAccess();

            SnmpWrapper.Instance().Create(ipAddress);

            TelnetWrapper.Instance().Create(ipAddress);

            string dhcpServerIp;

            if (activityData.ProductFamily == ProductFamilies.VEP)
            {
                Printer printer = PrinterFactory.Create(activityData.ProductFamily.ToString(), activityData.WirelessInterfaceAddress);

                if (string.IsNullOrEmpty(printer.MacAddress))
                {
                    TraceFactory.Logger.Info($"Failed to discover the mac address from IP address: {activityData.WirelessInterfaceAddress}");
                    return(new PluginExecutionResult(PluginResult.Failed, $"Failed to discover the mac address from IP address: {activityData.WirelessInterfaceAddress}"));
                }

                activityData.WirelessMacAddress = printer.MacAddress;

                string value = activityData.WirelessInterfaceAddress.Split('.')[2];

                dhcpServerIp = string.Format(CultureInfo.CurrentCulture, activityData.DhcpServerIp, value);

                using (DhcpApplicationServiceClient dhcpClient = DhcpApplicationServiceClient.Create(dhcpServerIp))
                {
                    string scope = dhcpClient.Channel.GetDhcpScopeIP(dhcpServerIp);
                    dhcpClient.Channel.DeleteReservation(dhcpServerIp, scope, activityData.WirelessInterfaceAddress, activityData.WirelessMacAddress);

                    if (dhcpClient.Channel.CreateReservation(dhcpServerIp, scope, activityData.WirelessInterfaceAddress, activityData.WirelessMacAddress, ReservationType.Both))
                    {
                        TraceFactory.Logger.Info($"Successfully created reservation for IP address: {activityData.WirelessInterfaceAddress}, Mac address: {activityData.WirelessMacAddress} for {ReservationType.Both}");
                    }
                    else
                    {
                        TraceFactory.Logger.Info($"Failed to create reservation for IP address: {activityData.WirelessInterfaceAddress}, Mac address: {activityData.WirelessMacAddress} for {ReservationType.Both}");
                        return(new PluginExecutionResult(PluginResult.Failed, $"Failed to create reservation for IP address: {activityData.WirelessInterfaceAddress}, Mac address: {activityData.WirelessMacAddress} for {ReservationType.Both}"));
                    }
                }
            }

            dhcpServerIp = activityData.DhcpServerIp.FormatWith(activityData.PrimaryInterfaceAddress.Split('.')[2]);

            using (DhcpApplicationServiceClient dhcpClient = DhcpApplicationServiceClient.Create(dhcpServerIp))
            {
                string wiredMacAddress = PrinterFactory.Create(activityData.ProductFamily.ToString(), activityData.PrimaryInterfaceAddress).MacAddress;


                if (string.IsNullOrEmpty(wiredMacAddress))
                {
                    TraceFactory.Logger.Info($"Failed to discover the mac address from IP address: {activityData.PrimaryInterfaceAddress}");
                    return(new PluginExecutionResult(PluginResult.Failed, $"Failed to discover the mac address from IP address: {activityData.PrimaryInterfaceAddress}"));
                }

                string scope = dhcpClient.Channel.GetDhcpScopeIP(dhcpServerIp);
                dhcpClient.Channel.DeleteReservation(dhcpServerIp, scope, activityData.PrimaryInterfaceAddress, wiredMacAddress);

                if (dhcpClient.Channel.CreateReservation(dhcpServerIp, scope, activityData.PrimaryInterfaceAddress, wiredMacAddress, ReservationType.Both))
                {
                    TraceFactory.Logger.Info($"Successfully created reservation for IP address: {activityData.PrimaryInterfaceAddress}, Mac address: {wiredMacAddress} for {ReservationType.Both}");
                }
                else
                {
                    TraceFactory.Logger.Info($"Failed to create reservation for IP address: {activityData.PrimaryInterfaceAddress}, Mac address: {wiredMacAddress} for {ReservationType.Both}");
                    return(new PluginExecutionResult(PluginResult.Failed, $"Failed to create reservation for IP address: {activityData.PrimaryInterfaceAddress}, Mac address: {wiredMacAddress} for {ReservationType.Both}"));
                }
            }

            activityData.SessionId = executionData.SessionId;

            if (null == _tests)
            {
                _tests = new WirelessTests(activityData);
            }

            // Execute the selected tests
            foreach (int testNumber in activityData.SelectedTests)
            {
                try
                {
                    ExecutionServices.SessionRuntime.AsInternal().WaitIfPaused();
                    _tests.RunTest(executionData, testNumber, IPAddress.Parse(ipAddress), (ProductFamilies)Enum.Parse(typeof(ProductFamilies), activityData.ProductFamily.ToString()));
                }
                catch (Exception ex)
                {
                    TraceFactory.Logger.Fatal($"Error while executing Test:{testNumber} {ex.Message}\n");
                }
            }

            EwsWrapper.Instance().Stop();

            return(new PluginExecutionResult(PluginResult.Passed));
        }
예제 #15
0
        public PluginExecutionResult Execute(PluginExecutionData executionData)
        {
            CtcSettings.Initialize(executionData);

            // create activity data
            WiFiDirectActivityData activityData = executionData.GetMetadata <WiFiDirectActivityData>(CtcMetadataConverter.Converters);

            string ipAddress = activityData.PrimaryInterfaceAddress;

            EwsWrapper.Instance().Create((PrinterFamilies)Enum.Parse(typeof(PrinterFamilies), activityData.ProductFamily.ToString()), activityData.ProductName, ipAddress, Path.Combine(activityData.SitemapPath, activityData.SitemapVersion), BrowserModel.Firefox, EwsAdapterType.WebDriverAdapter);

            EwsWrapper.Instance().Start();

            SnmpWrapper.Instance().Create(ipAddress);

            TelnetWrapper.Instance().Create(ipAddress);

            //string DhcpServerIp = string.Empty;

            //if (!(activityData.ProductFamily.EqualsIgnoreCase(PrinterFamilies.TPS.ToString()) || activityData.ProductFamily.EqualsIgnoreCase(PrinterFamilies.InkJet.ToString())))
            //{
            //	Printer printer = PrinterFactory.Create(activityData.ProductFamily, activityData.WirelessInterfaceAddress);

            //	if (null == printer.MacAddress)
            //	{
            //		TraceFactory.Logger.Info("Failed to discover the mac address from IP address: {0}".FormatWith(activityData.WirelessInterfaceAddress));
            //		return new PluginExecutionResult(PluginResult.Failed, "Failed to discover the mac address from IP address: {0}".FormatWith(activityData.WirelessInterfaceAddress));
            //	}

            //	activityData.WirelessMacAddress = printer.MacAddress;

            //	string value = activityData.WirelessInterfaceAddress.Split(new char[] { '.' })[2];

            //	DhcpServerIp = activityData.DhcpServerIp.FormatWith(value);

            //	using (DhcpApplicationServiceClient dhcpClient = DhcpApplicationServiceClient.Create(DhcpServerIp))
            //	{
            //		string scope = dhcpClient.Channel.GetDhcpScopeIP(DhcpServerIp);
            //		dhcpClient.Channel.DeleteReservation(DhcpServerIp, scope, activityData.WirelessInterfaceAddress, activityData.WirelessMacAddress);

            //		if (dhcpClient.Channel.CreateReservation(DhcpServerIp, scope, activityData.WirelessInterfaceAddress, activityData.WirelessMacAddress, ReservationType.Both))
            //		{
            //			TraceFactory.Logger.Info("Successfully created reservation for IP address: {0}, Mac address: {1} for {2}".FormatWith(activityData.WirelessInterfaceAddress, activityData.WirelessMacAddress, ReservationType.Both));
            //		}
            //		else
            //		{
            //			TraceFactory.Logger.Info("Failed to create reservation for IP address: {0}, Mac address: {1} for {2}".FormatWith(activityData.WirelessInterfaceAddress, activityData.WirelessMacAddress, ReservationType.Both));
            //			return new PluginExecutionResult(PluginResult.Failed, "Failed to create reservation for IP address: {0}, Mac address: {1} for {2}".FormatWith(activityData.WirelessInterfaceAddress, activityData.WirelessMacAddress, ReservationType.Both));
            //		}
            //	}
            //}

            //DhcpServerIp = activityData.DhcpServerIp.FormatWith(activityData.PrimaryInterfaceAddress.Split(new char[] { '.' })[2]);

            //using (DhcpApplicationServiceClient dhcpClient = DhcpApplicationServiceClient.Create(DhcpServerIp))
            //{
            //	string wiredMacAddress = SnmpWrapper.Instance().
            //	string scope = dhcpClient.Channel.GetDhcpScopeIP(DhcpServerIp);
            //	dhcpClient.Channel.DeleteReservation(DhcpServerIp, scope, activityData.PrimaryInterfaceAddress, wiredMacAddress);

            //	if (dhcpClient.Channel.CreateReservation(DhcpServerIp, scope, activityData.PrimaryInterfaceAddress, wiredMacAddress, ReservationType.Both))
            //	{
            //		TraceFactory.Logger.Info("Successfully created reservation for IP address: {0}, Mac address: {1} for {2}".FormatWith(activityData.PrimaryInterfaceAddress, wiredMacAddress, ReservationType.Both));
            //	}
            //	else
            //	{
            //		TraceFactory.Logger.Info("Failed to create reservation for IP address: {0}, Mac address: {1} for {2}".FormatWith(activityData.PrimaryInterfaceAddress, wiredMacAddress, ReservationType.Both));
            //		return new PluginExecutionResult(PluginResult.Failed, "Failed to create reservation for IP address: {0}, Mac address: {1} for {2}".FormatWith(activityData.PrimaryInterfaceAddress, wiredMacAddress, ReservationType.Both));
            //	}
            //}

            activityData.SessionId = executionData.SessionId;

            if (null == _tests)
            {
                _tests = new WiFiDirectTests(activityData);
            }

            // Execute the selected tests
            foreach (int testNumber in activityData.SelectedTests)
            {
                try
                {
                    ExecutionServices.SessionRuntime.AsInternal().WaitIfPaused();
                    _tests.RunTest(executionData, testNumber, IPAddress.Parse(ipAddress), (ProductFamilies)Enum.Parse(typeof(ProductFamilies), activityData.ProductFamily.ToString()));
                }
                catch (Exception ex)
                {
                    TraceFactory.Logger.Fatal("Error while executing Test:{0} {1}\n".FormatWith(testNumber, ex.Message));
                    continue;
                }
            }

            EwsWrapper.Instance().Stop();

            return(new PluginExecutionResult(PluginResult.Passed));
        }