/// <summary>
/// Initializes a new instance of the <see cref="EwsSettings" /> class.
/// </summary>
/// <param name="productName">Name of the product.</param>
/// <param name="productType">Type of the product.</param>
/// <param name="sitemapsLocation">The sitemaps Location.</param>
/// <param name="deviceAddress">The device address.</param>
/// <param name="browser">The browser.</param>
/// <param name="adapterType">Type of Adapter</param>
/// <param name="remoteControlServer">The remote control server.</param>
/// <param name="remoteControlPort">The remote control port.</param>
public EwsSettings
(
string productName,
PrinterFamilies productType,
string sitemapsLocation,
string deviceAddress,
BrowserModel browser,
TimeSpan pageNavigationDelay,
TimeSpan elementOperationDelay,
EwsAdapterType adapterType = EwsAdapterType.SeleniumServerRC,
string remoteControlServer = "localhost",
int remoteControlPort = 4444
)
: this()
{
ProductName = productName;
ProductType = productType;
SitemapsLocation = sitemapsLocation;
DeviceAddress = deviceAddress;
Browser = browser;
AdapterType = adapterType;
HttpRemoteControlHost = remoteControlServer;
HttpRemoteControlPort = remoteControlPort;
PageNavigationDelay = pageNavigationDelay;
ElementOperationDelay = elementOperationDelay;
}
/// <summary>
/// Create a printer based on the printer family (architecture) and ip address.
/// </summary>
/// <param name="family">Printer family</param>
/// <param name="ipAddress">IP Address</param>
/// <returns></returns>
public static Printer Create(string family, string ipAddress)
{
Printer printer = null;
PrinterFamilies familyEnum = (PrinterFamilies)Enum.Parse(typeof(PrinterFamilies), family);
switch (familyEnum)
{
case PrinterFamilies.InkJet:
printer = new SiriusPrinter(IPAddress.Parse(ipAddress));
break;
case PrinterFamilies.LFP:
printer = new PhoenixPrinter(IPAddress.Parse(ipAddress));
break;
case PrinterFamilies.TPS:
printer = new MarvellPrinter(IPAddress.Parse(ipAddress));
break;
case PrinterFamilies.VEP:
printer = new JediPrinter(IPAddress.Parse(ipAddress));
break;
}
return(printer);
}
/// <summary>
/// Create a printer based on the printer family (architecture) and ip address.
/// </summary>
/// <param name="family">Printer family</param>
/// <param name="ipAddress">IP Address</param>
/// <returns></returns>
public static Printer Create(PrinterFamilies family, IPAddress ipAddress)
{
Printer printer = null;
switch (family)
{
case PrinterFamilies.InkJet:
printer = new SiriusPrinter(ipAddress);
break;
case PrinterFamilies.LFP:
printer = new PhoenixPrinter(ipAddress);
break;
case PrinterFamilies.TPS:
printer = new MarvellPrinter(ipAddress);
break;
case PrinterFamilies.VEP:
printer = new JediPrinter(ipAddress);
break;
}
return(printer);
}
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));
}
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));
}
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));
}
/// <summary>
/// Print all files in specified folder
/// </summary>
/// <param name="ipAddress">IP Address of Printer</param>
/// <param name="printProtocol"><see cref=" Printer.Printer.PrintProtocol"/></param>
/// <param name="portNo">Port number for installation</param>
/// <param name="testNo">Test number</param>
/// <returns>true if all files printed successfully, false otherwise</returns>
public bool ComplexPrinting(string ipAddress, Printer.Printer.PrintProtocol printProtocol, int portNo, int testNo)
{
string[] files = Directory.GetFiles(_activityData.DocumentsPath);
if (null == files || 0 == files.Length)
{
TraceFactory.Logger.Info("Complex Printing failed. No files available.");
return(false);
}
string hostname = string.Empty;
if (Printer.Printer.PrintProtocol.IPPS.Equals(printProtocol))
{
if (!CtcUtility.IPPS_Prerequisite(IPAddress.Parse(ipAddress), out hostname))
{
TraceFactory.Logger.Info("Failed to perform pre-requisites for IPPS.");
return(false);
}
}
PrinterFamilies family = (PrinterFamilies)Enum.Parse(typeof(PrinterFamilies), Enum <ProductFamilies> .Value(_activityData.ProductFamily));
Printer.Printer printer = PrinterFactory.Create(family, IPAddress.Parse(ipAddress));
if (printer.Install(IPAddress.Parse(ipAddress), printProtocol, _activityData.DriverPackagePath, _activityData.DriverModel, portNo, hostname))
{
printer.Print(CtcUtility.CreateFile("Test {0} started.".FormatWith(testNo)));
// Subscribing for Print Queue Event
printer.PrintQueueError += printer_PrintQueueError;
if (!printer.Print(files))
{
TraceFactory.Logger.Info("Complex Printing failed. All jobs didn't print.");
return(false);
}
}
else
{
TraceFactory.Logger.Info("Complex Printing failed.");
return(false);
}
TraceFactory.Logger.Info("All jobs for Complex Printing printed successfully.");
return(true);
}
private EwsAdapter CreateAdapter()
{
BrowserModel browserModel = GetBrowserType(_activityData.BrowserNumber);
PrinterFamilies family = (PrinterFamilies)Enum.Parse(typeof(PrinterFamilies), _activityData.ProductCategory);
EwsSettings settings = new EwsSettings(_activityData.ProductName, family, _activityData.SitemapsVersion, _activityData.PrinterIP, browserModel, EwsAdapterType.WebDriverAdapter);
EwsSeleniumSettings seleniumSettings = new EwsSeleniumSettings();
string basePath = @"\\etlhubrepo\boi\CTC\Sitemaps";
string siteMapPath = @"{0}\{1}\{2}\{3}".FormatWith(basePath, _activityData.ProductCategory, _activityData.ProductName, _activityData.SitemapsVersion);
seleniumSettings.SeleniumChromeDriverPath = @"\\etlhubrepo\boi\CTC\SeleniumFiles\chromedriver.exe";
seleniumSettings.SeleniumIEDriverPath32 = @"\\etlhubrepo\boi\CTC\SeleniumFiles\IEDriverServer-x86.exe";
seleniumSettings.SeleniumIEDriverPath64 = @"\\etlhubrepo\boi\CTC\SeleniumFiles\IEDriverServer-x64.exe";
EwsAdapter adapter = new EwsAdapter(settings, seleniumSettings, siteMapPath);
return(adapter);
}
/// <summary>
/// Print all files in specified folder
/// </summary>
/// <param name="ipAddress">IP Address of Printer</param>
/// <param name="testNo">Test number</param>
/// <param name="isPassiveMode">Passive/ Active mode for FTP</param>
/// <returns>true if all files printed successfully, false otherwise</returns>
public bool ComplexPrinting(string ipAddress, int testNo, bool isPassiveMode = false)
{
string[] files = Directory.GetFiles(_activityData.DocumentsPath);
if (null == files || 0 == files.Length)
{
TraceFactory.Logger.Info("Complex Printing failed. No files available.");
return(false);
}
PrinterFamilies family = (PrinterFamilies)Enum.Parse(typeof(PrinterFamilies), Enum <ProductFamilies> .Value(_activityData.ProductFamily));
Printer.Printer printer = PrinterFactory.Create(family, IPAddress.Parse(ipAddress));
if (printer.PrintWithFtp(IPAddress.Parse(ipAddress), string.Empty, string.Empty, files, isPassiveMode: isPassiveMode))
{
TraceFactory.Logger.Info("All jobs for Complex Printing printed successfully.");
return(true);
}
else
{
TraceFactory.Logger.Info("Complex Printing failed. All jobs didn't print successfully.");
return(false);
}
}
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));
}
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);
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)
{
CtcSettings.Initialize(executionData);
ComplexPrintActivityData activityData = executionData.GetMetadata <ComplexPrintActivityData>(CtcMetadataConverter.Converters);
/* Complex printing plugin might use more than 1 client machine based on user scenario.
* All inputs related to printer are maintained in a configuration file in share location (etlhubrepo\boi\CTC\<Product_Family>)
* Since multiple machines are trying to access the config file, file is copied to local machine.
* */
// Get details from configuration file
string configFilePath = Path.Combine(CtcSettings.ConnectivityShare, activityData.ProductFamily.ToString(), "CNP.xml");
TraceFactory.Logger.Debug("Config File path: {0}".FormatWith(configFilePath));
FileStream file = null;
try
{
XmlDocument configFile = new XmlDocument();
string tempFilePath = Path.Combine(Path.GetTempPath(), "CNP.xml");
File.Copy(configFilePath, tempFilePath, true);
file = new FileStream(tempFilePath, FileMode.Open, FileAccess.Read);
configFile.Load(file);
activityData.Ipv4Address = configFile.DocumentElement.SelectSingleNode("IPv4Address").InnerText;
activityData.DriverPackagePath = configFile.DocumentElement.SelectSingleNode("DriverPath").InnerText;
activityData.DriverModel = configFile.DocumentElement.SelectSingleNode("DriverModel").InnerText;
activityData.ProductName = configFile.DocumentElement.SelectSingleNode("ProductName").InnerText;
activityData.DocumentsPath = configFile.DocumentElement.SelectSingleNode("FilesPath").InnerText;
activityData.SitemapsVersion = configFile.DocumentElement.SelectSingleNode("Sitemaps").InnerText;
activityData.PrinterConnectivity = ConnectivityType.Wired;
}
catch (Exception exception)
{
TraceFactory.Logger.Fatal("Failed to read configuration from xml document. Exception details: {0}".FormatWith(exception.JoinAllErrorMessages()));
}
finally
{
if (null != file)
{
file.Close();
}
}
/* If a WS Print test is selected in user scenario, a pop-up needs to be shown to 'Add the printer'.
* Read through all selected tests and keep track if WSP pop-up needs to be shown up.
* */
// Check if WSP test is selected by checking the test attributes for each test
bool isWSPSelected = false;
foreach (int testNumber in activityData.SelectedTests)
{
// Fetch the TestDetailsAttribute of the test method matching the testNumber
var attributes = typeof(ComplexPrintTests).GetMethods().Where(item => item.GetCustomAttributes(new TestDetailsAttribute().GetType(), false).Length > 0 &&
((TestDetailsAttribute)item.GetCustomAttributes(new TestDetailsAttribute().GetType(), false)[0]).Id.Equals(testNumber))
.Select(x => x.GetCustomAttributes(new TestDetailsAttribute().GetType(), false)[0]);
TestDetailsAttribute testAttributes = (TestDetailsAttribute)attributes.FirstOrDefault();
if (testAttributes.Category.Contains("WSP", StringComparison.CurrentCultureIgnoreCase))
{
isWSPSelected = true;
break;
}
}
if (isWSPSelected)
{
TraceFactory.Logger.Debug("Please add WS Printer on client machine: {0}".FormatWith(Environment.MachineName));
}
/* To keep track of whether a WSP test is added in any of the user scenario, a common file is maintained under shared location and all the clients need to update this file on WSP status.
* Folder structure: etlhubrepo\boi\CTC\<Product_Family>temp\<Session_ID>.xml
* Since many clients will be trying to write data to the xml file, check if xml is already created (by some other client), create if not.
* If a WSP test is selected, an entry is made with 'Yes' as the value, else 'No' with machine hostname as the unique identifier for the node.
* Status for the WS Print addition is maintained in 'Status' attribute. If scenario doesn't have a WSP test selected, 'Completed' status is added by default. Otherwise 'In Progress' is added.
*
* Locking mechanism:
* Since its a shared file, a lock is applied when a file is in use by a machine. Lock file for writing the data and release once completed.
* Acquire resource for max of 20 seconds to perform write operation. Wait for max of 3 minutes to use resource for writing into the file. (Waiting in Queue to write into the file)
* */
string configFolder = Path.Combine(CtcSettings.ConnectivityShare, activityData.ProductFamily.ToString(), "temp");
// Check if folder exists already.
if (!Directory.Exists(configFolder))
{
Directory.CreateDirectory(configFolder);
}
string xmlFilePath = Path.Combine(configFolder, executionData.SessionId + ".xml");
XElement machines = null;
// Check if file exists already. Create root node 'Machines' if file is not created else load the file
if (!File.Exists(xmlFilePath))
{
machines = new XElement("Machines");
}
else
{
XDocument xmlDocument = XDocument.Load(xmlFilePath);
machines = xmlDocument.Element("Machines");
}
ReaderWriterLock fileLock = new ReaderWriterLock();
bool isFileWritten = false;
DateTime currentTime = DateTime.Now;
TimeSpan waitTime = TimeSpan.FromMinutes(3);
Random randomTime = new Random();
do
{
// Since many clients are trying to access the file, generate a random timeout for acquiring lock on the file.
int timeOut = randomTime.Next(10, 20);
if (!fileLock.IsWriterLockHeld)
{
fileLock.AcquireWriterLock(TimeSpan.FromSeconds(timeOut));
XElement machine = new XElement("Machine", new XAttribute("VM_Name", Environment.MachineName),
new XAttribute("WSP_Print", isWSPSelected ? "Yes" : "No"),
new XAttribute("Status", isWSPSelected ? "In Progress" : "Completed"));
machines.Add(machine);
machines.Save(xmlFilePath);
// Wait for sometime to release the lock after saving file.
Thread.Sleep(TimeSpan.FromSeconds(10));
isFileWritten = true;
fileLock.ReleaseWriterLock();
}
} while (!isFileWritten && DateTime.Now.Subtract(waitTime) <= currentTime);
/* Check if printer is accessible with IPv4 address and IPv6 addresses: Linklocal, Stateless and Stateful address.
* Pop-up a message box if printer address is not pinging.
* */
PrinterFamilies family = (PrinterFamilies)Enum.Parse(typeof(PrinterFamilies), Enum <ProductFamilies> .Value(activityData.ProductFamily));
Printer.Printer printer = PrinterFactory.Create(family, IPAddress.Parse(activityData.Ipv4Address));
// If printer is not available, assign default IPAddress
if (printer.PingUntilTimeout(IPAddress.Parse(activityData.Ipv4Address), 1))
{
// Get All Ipv6 Addresses
activityData.Ipv6LinkLocalAddress = printer.IPv6LinkLocalAddress == null ? string.Empty : printer.IPv6LinkLocalAddress.ToString();
activityData.Ipv6StateFullAddress = printer.IPv6StateFullAddress == null ? string.Empty : printer.IPv6StateFullAddress.ToString();
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;
}
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"));
}
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"));
}
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"));
}
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"));
}
/* Since multiple clients can access drivers, print driver is copied to local machine so as to avoid 'File in use' exception.
* Driver path is updated to local temp directory for further use.
* */
string tempDriverDirectory = Path.Combine(Path.GetTempPath(), "PrintDriver");
TraceFactory.Logger.Debug("Local printer driver location: {0}".FormatWith(tempDriverDirectory));
if (Directory.Exists(tempDriverDirectory))
{
Directory.Delete(tempDriverDirectory, true);
}
foreach (string dirPath in Directory.GetDirectories(activityData.DriverPackagePath, "*", SearchOption.AllDirectories))
{
Directory.CreateDirectory(dirPath.Replace(activityData.DriverPackagePath, tempDriverDirectory));
}
foreach (string filePath in Directory.GetFiles(activityData.DriverPackagePath, "*.*", SearchOption.AllDirectories))
{
File.Copy(filePath, filePath.Replace(activityData.DriverPackagePath, tempDriverDirectory), true);
}
activityData.DriverPackagePath = tempDriverDirectory;
// By default, adding P9100 printer so that driver installation is complete while adding WS Printer.
printer.Install(IPAddress.Parse(activityData.Ipv4Address), Printer.Printer.PrintProtocol.RAW, activityData.DriverPackagePath, activityData.DriverModel, 9100);
// If WSP test is selected, Show a pop-up to Add the printer.
if (isWSPSelected)
{
/* If a WSP test is selected in any scenario created by user, pop a message box to add the printer.
* Status on whether a WSP test is selected are maintained in the config file (etlhubrepo\boi\CTC\<Product_Family>temp\<Session_ID>.xml) with attribute 'WSP_Print'.
* In case this scenario is added with WSP test, Pop-up message. Once the Ok button is clicked, updated the 'Status' on config file to 'Completed'.
* */
XElement localMachine = null;
XDocument document = XDocument.Load(xmlFilePath);
XElement element = document.Element("Machines");
foreach (var vm in element.Elements("Machine"))
{
if (vm.Attribute("VM_Name").Value.Equals(Environment.MachineName))
{
localMachine = vm;
TraceFactory.Logger.Info("Machine: {0}".FormatWith(localMachine.Attribute("VM_Name").Value));
break;
}
}
MessageBox.Show("Add WS Printer and click 'OK'.", "Add WS Printer", MessageBoxButtons.OK, MessageBoxIcon.Information);
localMachine.SetAttributeValue("Status", "Completed");
element.Save(xmlFilePath);
}
/* Wait till all clients are ready for execution: If a client is configured with WSP test, wait till user adds the printer.
* This case is handled with updation of the config file on status of WS Printer installation.
* Traverse through all Elements and check for 'Status' attribute to know the status on installation of WS Printer.
* */
bool isWSPrinterInstalled = true;
do
{
TraceFactory.Logger.Debug("Waiting for all clients to complete WS Printer installation.");
// In case isWSPrinterInstalled is set to false while traversing through the config file, set it back to true for next iteration
isWSPrinterInstalled = true;
// Wait for some time so that other clients update the status on WS Printer installation
Thread.Sleep(TimeSpan.FromSeconds(10));
// Reload the file to get the most updated data
XDocument xDocument = XDocument.Load(xmlFilePath);
XElement xElement = xDocument.Element("Machines");
foreach (var vm in xElement.Elements("Machine"))
{
isWSPrinterInstalled &= "Completed".Equals(vm.Attribute("Status").Value);
}
} while (!isWSPrinterInstalled);
if (null == _printTests)
{
_printTests = new ComplexPrintTests(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)
{
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));
}