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);
EwsActivityData data = executionData.GetMetadata <EwsActivityData>(CtcMetadataConverter.Converters);
if (null == _tests)
{
_tests = new EwsTests(data);
}
foreach (int testNumber in data.TestNumbers)
{
try
{
ExecutionServices.SessionRuntime.AsInternal().WaitIfPaused();
_tests.RunTest(executionData, testNumber, IPAddress.Parse(data.PrinterIP), (ProductFamilies)Enum.Parse(typeof(ProductFamilies), data.ProductCategory));
}
catch (Exception pluginException)
{
TraceFactory.Logger.Error("Error while pausing: " + pluginException.Message);
}
}
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));
}
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));
}
/// <summary>
/// Load the data based on the product family
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void ConfigurationParametersForm_Load(object sender, EventArgs e)
{
// Load default values on to the form.
info_Label.Text = "You are trying to edit configuration parameters for '" + _productFamilies.ToString() + "' product family.";
// Load the printer names based on the printer family
Collection <string> productNames = CtcSettings.GetProducts(_productFamilies.ToString());
productName_ComboBox.Items.Clear();
if (productNames.Count != 0)
{
for (int i = 0; i < productNames.Count; i++)
{
productName_ComboBox.Items.Add(productNames[i]);
}
}
else
{
MessageBox.Show("There are no Products available for {0} Product Category in the database.\nPlease add the Product and try again.".FormatWith(_productFamilies.ToString()), "Product Loading Failure", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
productName_ComboBox.SelectedIndex = 0;
// Load the printer driver settings
print_PrintDriverSelector.PrinterFamily = _productFamilies.ToString();
print_PrintDriverSelector.PrinterName = productName_ComboBox.SelectedItem.ToString();
sitemapVersionSelector.PrinterFamily = _productFamilies.ToString();
sitemapVersionSelector.PrinterName = productName_ComboBox.SelectedItem.ToString();
// Load the configuration data from CNP.xml on to the form
LoadConfigurationData();
}
public void Initialize(PluginEnvironment environment)
{
_activityData = new CertificateManagementActivityData();
CtcSettings.Initialize(environment);
LoadUI();
}
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 void Initialize(PluginEnvironment environment)
{
_activityData = new IPConfigurationActivityData();
CtcSettings.Initialize(environment);
LoadUI();
}
public void Initialize(PluginEnvironment environment)
{
_activityData = new TelnetSnmpActivityData();
CtcSettings.Initialize(environment);
LoadUI();
}
void IPluginConfigurationControl.Initialize(PluginEnvironment environment)
{
_activityData = new ConnectivityPrintActivityData();
CtcSettings.Initialize(environment);
LoadUI();
}
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));
}
public void Initialize(PluginEnvironment environment)
{
_activityData = new IPSecurityActivityData();
CtcSettings.Initialize(environment);
LoadUI();
}
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 void Initialize(PluginEnvironment environment)
{
_activityData = new WirelessActivityData();
CtcSettings.Initialize(environment);
LoadUi();
}
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);
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
SecurityActivityData activityData = executionData.GetMetadata <SecurityActivityData>(CtcMetadataConverter.Converters);
Printer.Printer printer = PrinterFactory.Create(activityData.ProductFamily, activityData.WiredIPv4Address);
activityData.WiredMacAddress = printer.MacAddress;
TraceFactory.Logger.Info("Wired Mac Address: {0}".FormatWith(activityData.WiredMacAddress));
if (activityData.ProductFamily.EqualsIgnoreCase(PrinterFamilies.VEP.ToString()))
{
IPAddress ipAddress;
if (IPAddress.TryParse(activityData.SecondaryWiredIPv4Address, out ipAddress))
{
printer = PrinterFactory.Create(activityData.ProductFamily, activityData.SecondaryWiredIPv4Address);
activityData.SecondaryWiredMacAddress = printer.MacAddress;
TraceFactory.Logger.Info("Secondary Wired Mac Address: {0}".FormatWith(activityData.SecondaryWiredMacAddress));
}
if (IPAddress.TryParse(activityData.WirelessIPv4Address, out ipAddress))
{
printer = PrinterFactory.Create(activityData.ProductFamily, activityData.WirelessIPv4Address);
activityData.WirelessMacAddress = printer.MacAddress;
TraceFactory.Logger.Info("Wireless Mac Address: {0}".FormatWith(activityData.WirelessMacAddress));
}
}
List <NetworkInterface> clientNetworks = NetworkInterface.GetAllNetworkInterfaces().Where(n => n.OperationalStatus == OperationalStatus.Up).ToList();
List <IPAddress> localAddresses = NetworkUtil.GetLocalAddresses().Where(x => x.AddressFamily == AddressFamily.InterNetwork).ToList();
EwsWrapper.Instance().Create(Enum <PrinterFamilies> .Parse(activityData.ProductFamily), activityData.ProductName, activityData.WiredIPv4Address, Path.Combine(activityData.SitemapPath, activityData.SitemapsVersion), BrowserModel.Firefox);
EwsWrapper.Instance().Start();
EwsWrapper.Instance().EnableSnmpv1v2ReadWriteAccess();
if (!SecurityScenarioPrerequisites(activityData, clientNetworks, localAddresses))
{
return(new PluginExecutionResult(PluginResult.Failed, "Failed in Scenario pre-requisites"));
}
//create instance of SNMP wrapper
SnmpWrapper.Instance().Create(activityData.WiredIPv4Address);
//create instance of Telnet wrapper
TelnetWrapper.Instance().Create(activityData.WiredIPv4Address);
if (null == _securitytests)
{
_securitytests = new SecurityTests(activityData);
}
// Execute the selected tests
foreach (int testNumber in activityData.SelectedTests)
{
try
{
ExecutionServices.SessionRuntime.AsInternal().WaitIfPaused();
_securitytests.RunTest(executionData, testNumber, IPAddress.Parse(activityData.WiredIPv4Address), (ProductFamilies)Enum.Parse(typeof(ProductFamilies), activityData.ProductFamily));
}
catch (Exception ex)
{
TraceFactory.Logger.Fatal("Error while executing Test:{0} \n".FormatWith(testNumber, ex.Message));
}
}
EwsWrapper.Instance().Stop();
ManageClientReservation(clientNetworks, localAddresses, activityData, true);
return(new PluginExecutionResult(PluginResult.Passed));
}
public void Initialize(PluginEnvironment environment)
{
_activityData = new NetworkNamingServiceActivityData();
CtcSettings.Initialize(environment);
LoadUI();
}
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 void Initialize(PluginConfigurationData configuration, PluginEnvironment environment)
{
_activityData = configuration.GetMetadata <IPSecurityActivityData>(CtcMetadataConverter.Converters);
CtcSettings.Initialize(environment);
LoadUI();
}
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);
// 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 void Initialize(PluginEnvironment environment)
{
_activityData = new ComplexPrintActivityData();
CtcSettings.Initialize(environment);
LoadUI();
}
void IPluginConfigurationControl.Initialize(PluginConfigurationData configuration, PluginEnvironment environment)
{
_activityData = configuration.GetMetadata <ConnectivityPrintActivityData>(CtcMetadataConverter.Converters);
CtcSettings.Initialize(environment);
LoadUI();
}
public PluginExecutionResult Execute(PluginExecutionData executionData)
{
CtcSettings.Initialize(executionData);
// create activity data
WiFiDirectActivityData activityData = executionData.GetMetadata <WiFiDirectActivityData>(CtcMetadataConverter.Converters);
string ipAddress = activityData.PrimaryInterfaceAddress;
EwsWrapper.Instance().Create((PrinterFamilies)Enum.Parse(typeof(PrinterFamilies), activityData.ProductFamily.ToString()), activityData.ProductName, ipAddress, Path.Combine(activityData.SitemapPath, activityData.SitemapVersion), BrowserModel.Firefox, EwsAdapterType.WebDriverAdapter);
EwsWrapper.Instance().Start();
SnmpWrapper.Instance().Create(ipAddress);
TelnetWrapper.Instance().Create(ipAddress);
//string DhcpServerIp = string.Empty;
//if (!(activityData.ProductFamily.EqualsIgnoreCase(PrinterFamilies.TPS.ToString()) || activityData.ProductFamily.EqualsIgnoreCase(PrinterFamilies.InkJet.ToString())))
//{
// Printer printer = PrinterFactory.Create(activityData.ProductFamily, activityData.WirelessInterfaceAddress);
// if (null == printer.MacAddress)
// {
// TraceFactory.Logger.Info("Failed to discover the mac address from IP address: {0}".FormatWith(activityData.WirelessInterfaceAddress));
// return new PluginExecutionResult(PluginResult.Failed, "Failed to discover the mac address from IP address: {0}".FormatWith(activityData.WirelessInterfaceAddress));
// }
// activityData.WirelessMacAddress = printer.MacAddress;
// string value = activityData.WirelessInterfaceAddress.Split(new char[] { '.' })[2];
// DhcpServerIp = activityData.DhcpServerIp.FormatWith(value);
// using (DhcpApplicationServiceClient dhcpClient = DhcpApplicationServiceClient.Create(DhcpServerIp))
// {
// string scope = dhcpClient.Channel.GetDhcpScopeIP(DhcpServerIp);
// dhcpClient.Channel.DeleteReservation(DhcpServerIp, scope, activityData.WirelessInterfaceAddress, activityData.WirelessMacAddress);
// if (dhcpClient.Channel.CreateReservation(DhcpServerIp, scope, activityData.WirelessInterfaceAddress, activityData.WirelessMacAddress, ReservationType.Both))
// {
// TraceFactory.Logger.Info("Successfully created reservation for IP address: {0}, Mac address: {1} for {2}".FormatWith(activityData.WirelessInterfaceAddress, activityData.WirelessMacAddress, ReservationType.Both));
// }
// else
// {
// TraceFactory.Logger.Info("Failed to create reservation for IP address: {0}, Mac address: {1} for {2}".FormatWith(activityData.WirelessInterfaceAddress, activityData.WirelessMacAddress, ReservationType.Both));
// return new PluginExecutionResult(PluginResult.Failed, "Failed to create reservation for IP address: {0}, Mac address: {1} for {2}".FormatWith(activityData.WirelessInterfaceAddress, activityData.WirelessMacAddress, ReservationType.Both));
// }
// }
//}
//DhcpServerIp = activityData.DhcpServerIp.FormatWith(activityData.PrimaryInterfaceAddress.Split(new char[] { '.' })[2]);
//using (DhcpApplicationServiceClient dhcpClient = DhcpApplicationServiceClient.Create(DhcpServerIp))
//{
// string wiredMacAddress = SnmpWrapper.Instance().
// string scope = dhcpClient.Channel.GetDhcpScopeIP(DhcpServerIp);
// dhcpClient.Channel.DeleteReservation(DhcpServerIp, scope, activityData.PrimaryInterfaceAddress, wiredMacAddress);
// if (dhcpClient.Channel.CreateReservation(DhcpServerIp, scope, activityData.PrimaryInterfaceAddress, wiredMacAddress, ReservationType.Both))
// {
// TraceFactory.Logger.Info("Successfully created reservation for IP address: {0}, Mac address: {1} for {2}".FormatWith(activityData.PrimaryInterfaceAddress, wiredMacAddress, ReservationType.Both));
// }
// else
// {
// TraceFactory.Logger.Info("Failed to create reservation for IP address: {0}, Mac address: {1} for {2}".FormatWith(activityData.PrimaryInterfaceAddress, wiredMacAddress, ReservationType.Both));
// return new PluginExecutionResult(PluginResult.Failed, "Failed to create reservation for IP address: {0}, Mac address: {1} for {2}".FormatWith(activityData.PrimaryInterfaceAddress, wiredMacAddress, ReservationType.Both));
// }
//}
activityData.SessionId = executionData.SessionId;
if (null == _tests)
{
_tests = new WiFiDirectTests(activityData);
}
// Execute the selected tests
foreach (int testNumber in activityData.SelectedTests)
{
try
{
ExecutionServices.SessionRuntime.AsInternal().WaitIfPaused();
_tests.RunTest(executionData, testNumber, IPAddress.Parse(ipAddress), (ProductFamilies)Enum.Parse(typeof(ProductFamilies), activityData.ProductFamily.ToString()));
}
catch (Exception ex)
{
TraceFactory.Logger.Fatal("Error while executing Test:{0} {1}\n".FormatWith(testNumber, ex.Message));
continue;
}
}
EwsWrapper.Instance().Stop();
return(new PluginExecutionResult(PluginResult.Passed));
}