private bool DeleteReservation(string ipAddress, string dhcpServer, string macAddress)
{
if (!string.IsNullOrEmpty(ipAddress))
{
using (DhcpApplicationServiceClient dhcpClient = DhcpApplicationServiceClient.Create(dhcpServer))
{
string scope = dhcpClient.Channel.GetDhcpScopeIP(dhcpServer);
if (dhcpClient.Channel.DeleteReservation(dhcpServer, scope, ipAddress, macAddress))
{
TraceFactory.Logger.Info("Successfully created reservation for IP address: {0}, Mac address: {1} for both dhcp and bootp in server: {2}".FormatWith(ipAddress, macAddress, dhcpServer));
return(true);
}
else
{
TraceFactory.Logger.Info("Failed to create reservation for IP address: {0}, Mac address: {1} for both dhcp and bootp in server: {2}".FormatWith(ipAddress, macAddress, dhcpServer));
return(false);
}
}
}
else
{
return(false);
}
}
private static void ServerConfiguration(ref IPConfigurationActivityData activityData)
{
// Configuring the Primary DHCP Server
string primaryVLAN = (activityData.PrimaryDhcpServerIPAddress).Split(new char[] { '.' })[2];
string defaultDomainName = $"ctc{primaryVLAN}.automation.com";
string defaultDNSSuffix = $"ctc{primaryVLAN}.automation.com";
string defaultHostName = $"ctc{primaryVLAN}HostName";
string defaultWINSDNSv4Address = $"{activityData.PrimaryDhcpServerIPAddress} {activityData.SecondDhcpServerIPAddress}";
string defaultWINSDNSv6Address = $"{activityData.PrimaryDHCPServerIPv6Address} {activityData.SecondaryDHCPServerIPv6Address}";
TraceFactory.Logger.Info($"{primaryVLAN} {defaultDomainName} {defaultDNSSuffix} {defaultHostName} {defaultWINSDNSv4Address} {defaultWINSDNSv6Address}");
DhcpApplicationServiceClient serviceMethodPrimaryServer = DhcpApplicationServiceClient.Create(activityData.PrimaryDhcpServerIPAddress);
serviceMethodPrimaryServer.Channel.SetDnsServer(activityData.PrimaryDhcpServerIPAddress, activityData.DHCPScopeIPAddress, defaultWINSDNSv4Address);
serviceMethodPrimaryServer.Channel.SetWinsServer(activityData.PrimaryDhcpServerIPAddress, activityData.DHCPScopeIPAddress, defaultWINSDNSv4Address);
serviceMethodPrimaryServer.Channel.SetHostName(activityData.PrimaryDhcpServerIPAddress, activityData.DHCPScopeIPAddress, defaultHostName);
serviceMethodPrimaryServer.Channel.SetDomainName(activityData.PrimaryDhcpServerIPAddress, activityData.DHCPScopeIPAddress, defaultDomainName);
serviceMethodPrimaryServer.Channel.SetDnsSuffix(activityData.PrimaryDhcpServerIPAddress, activityData.DHCPScopeIPAddress, defaultDNSSuffix);
serviceMethodPrimaryServer.Channel.SetDnsv6ServerIP(activityData.PrimaryDhcpServerIPAddress, activityData.DHCPScopeIPv6Address, defaultWINSDNSv6Address);
serviceMethodPrimaryServer.Channel.SetDomainSearchList(activityData.PrimaryDhcpServerIPAddress, activityData.DHCPScopeIPv6Address, defaultDNSSuffix);
// Configuring the Secondary DHCP Server
string secondaryVLAN = (activityData.SecondDhcpServerIPAddress).Split(new char[] { '.' })[2];
defaultDomainName = $"ctc{secondaryVLAN}.automation.com";
defaultDNSSuffix = $"ctc{secondaryVLAN}.automation.com";
defaultHostName = $"ctc{secondaryVLAN}HostName";
defaultWINSDNSv4Address = $"{activityData.SecondDhcpServerIPAddress} {activityData.PrimaryDhcpServerIPAddress}";
defaultWINSDNSv6Address = $"{activityData.SecondaryDHCPServerIPv6Address} {activityData.PrimaryDHCPServerIPv6Address}";
TraceFactory.Logger.Info($"{secondaryVLAN} {defaultDomainName} {defaultDNSSuffix} {defaultHostName} {defaultWINSDNSv4Address} {defaultWINSDNSv6Address}");
DhcpApplicationServiceClient serviceMethodSecondaryServer = DhcpApplicationServiceClient.Create(activityData.SecondDhcpServerIPAddress);
serviceMethodSecondaryServer.Channel.SetDnsServer(activityData.SecondDhcpServerIPAddress, activityData.SecondaryDHCPServerIPv4Scope, defaultWINSDNSv4Address);
serviceMethodSecondaryServer.Channel.SetWinsServer(activityData.SecondDhcpServerIPAddress, activityData.SecondaryDHCPServerIPv4Scope, defaultWINSDNSv4Address);
serviceMethodSecondaryServer.Channel.SetHostName(activityData.SecondDhcpServerIPAddress, activityData.SecondaryDHCPServerIPv4Scope, defaultHostName);
serviceMethodSecondaryServer.Channel.SetDomainName(activityData.SecondDhcpServerIPAddress, activityData.SecondaryDHCPServerIPv4Scope, defaultDomainName);
serviceMethodSecondaryServer.Channel.SetDnsSuffix(activityData.SecondDhcpServerIPAddress, activityData.SecondaryDHCPServerIPv4Scope, defaultDNSSuffix);
serviceMethodSecondaryServer.Channel.SetDnsv6ServerIP(activityData.SecondDhcpServerIPAddress, activityData.SecondaryDHCPServerIPv6Scope, defaultWINSDNSv6Address);
serviceMethodSecondaryServer.Channel.SetDomainSearchList(activityData.SecondDhcpServerIPAddress, activityData.SecondaryDHCPServerIPv6Scope, defaultDNSSuffix);
}
private bool CreateReservation(string dhcpServerAddress, string scope, string ipAddress, string macAddress)
{
DhcpApplicationServiceClient dhcpClient = DhcpApplicationServiceClient.Create(dhcpServerAddress);
// Delete Reservation is not validated to handle cases where reservation is not present
dhcpClient.Channel.DeleteReservation(dhcpServerAddress, scope, ipAddress, macAddress);
if (dhcpClient.Channel.CreateReservation(dhcpServerAddress, scope, ipAddress, macAddress, ReservationType.Both))
{
TraceFactory.Logger.Info("Printer IP Address Reservation in DHCP Server for both DHCP and BOOTP for IP Address: {0} Mac Address: {1}: Succeeded".FormatWith(ipAddress, macAddress));
return(true);
}
else
{
TraceFactory.Logger.Info("Printer IP Address Reservation in DHCP Server for both DHCP and BOOTP: Failed");
return(false);
}
}
/// <summary>
/// Check whether IP Config Service and DHCP service is up and running.
/// </summary>
/// <returns>true if both the services are running, false otherwise</returns>
private static bool IsServicesRunning(string primaryServer, string secondaryServer)
{
// TODO: Check if WindowsServerService is running
DhcpApplicationServiceClient primaryService = DhcpApplicationServiceClient.Create(primaryServer);
DhcpApplicationServiceClient secondaryService = DhcpApplicationServiceClient.Create(secondaryServer);
if (!(primaryService.Channel.IsDhcpServiceRunning() && secondaryService.Channel.IsDhcpServiceRunning()))
{
MessageBox.Show(string.Concat("WindowsServerService is not running on DHCP server.\n\n",
"Check whether DHCP and WindowsServerService are running on DHCP server.\n",
"Start 'DHCPServer' and 'WindowsServerService' services if not started on both Primary: {0} and Secondary: {1} server.\n".FormatWith(primaryServer, secondaryServer),
"Check if Time Zone and Date & Time are in sync between DHCP server and Client."),
"DHCP/ IP Configuration Service Not Running", MessageBoxButtons.OK, MessageBoxIcon.Error);
return(false);
}
return(true);
}
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));
}
protected override void OnStart(string[] args)
{
base.OnStart(args);
Logger.LogDebug("Starting Windows Server Service");
// Create service host for Service Contract
_dhcpServiceHost = new WcfHost <IDhcpApplication>(typeof(DhcpApplication), MessageTransferType.Http, DhcpApplicationServiceClient.BuildUri("localhost"));
_dhcpServiceHost.Open();
_dnsServiceHost = new WcfHost <IDnsApplication>(typeof(DnsApplication), MessageTransferType.Http, DnsApplicationServiceClient.BuildUri("localhost"));
_dnsServiceHost.Open();
_winsServiceHost = new WcfHost <IWinsApplication>(typeof(WinsApplication), MessageTransferType.Http, WinsApplicationServiceClient.BuildUri("localhost"));
_winsServiceHost.Open();
_kiwiSyslogServiceHost = new WcfHost <IKiwiSyslogApplication>(typeof(KiwiSyslogApplication), MessageTransferType.Http, KiwiSyslogApplicationServiceClient.BuildUri("localhost"));
_kiwiSyslogServiceHost.Open();
_radiusServiceHost = new WcfHost <IRadiusApplication>(typeof(RadiusApplication), MessageTransferType.Http, RadiusApplicationServiceClient.BuildUri("localhost"));
_radiusServiceHost.Open();
_systemConfigurationServiceHost = new WcfHost <ISystemConfiguration>(typeof(SystemConfiguration), MessageTransferType.Http, SystemConfigurationClient.BuildUri("localhost"));
_systemConfigurationServiceHost.Open();
}
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));
}
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));
}
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));
}
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));
}
