1016 lines
45 KiB
C#
1016 lines
45 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
using DTS.Common;
|
|
using DTS.DASLib.Service;
|
|
using DTS.Common.Utilities.Logging;
|
|
using DTS.Common.Interface.DASFactory;
|
|
using DTS.Common.Enums.DASFactory;
|
|
using System.Collections.Concurrent;
|
|
|
|
namespace DTS.DASLib.DASFactory
|
|
{
|
|
internal class EthernetHandling : DeviceHandling
|
|
{
|
|
/// <summary>
|
|
/// Timeout in milliseconds to connect an Ethernet Slice device
|
|
/// </summary>
|
|
public int ConnectEthernetSliceTimeout { get; set; }
|
|
|
|
/// <summary>
|
|
/// Timeout in milliseconds to connect an Ethernet Ribeye device
|
|
/// </summary>
|
|
public int ConnectEthernetRibeyeTimeout { get; set; }
|
|
|
|
/// <summary>
|
|
/// Timeout in milliseconds to connect an Ethernet Slice2 device
|
|
/// </summary>
|
|
public int ConnectEthernetSlice2Timeout { get; set; }
|
|
|
|
/// <summary>
|
|
/// Timeout in milliseconds to connect an Ethernet Slice1.5 device
|
|
/// </summary>
|
|
public int ConnectEthernetSlice15Timeout { get; set; }
|
|
/// <summary>
|
|
/// Timeout in milliseconds to connect an Ethernet Slice6 device
|
|
/// </summary>
|
|
public int ConnectEthernetSlice6Timeout { get; set; }
|
|
|
|
/// <summary>
|
|
/// Timeout in milliseconds to connect an Ethernet TSR AIR device
|
|
/// </summary>
|
|
public int ConnectEthernetTsrAirTimeout { get; set; }
|
|
public int ConnectEthernetSliceProDBTimeout { get; set; }
|
|
|
|
private ManualResetEvent _slicedbCanConnectEvent = new ManualResetEvent(false);
|
|
private bool _slicedbCanConnect = true;
|
|
private volatile bool _slicedbShouldDisconnect;
|
|
|
|
//17649 Issues connecting/disconnecting to SLICE Distributor
|
|
//expose this so that thread within dasfactory has access
|
|
public bool SLICEDBShouldDisconnect => _slicedbShouldDisconnect;
|
|
|
|
private DASFactory factory { get; set; }
|
|
// device type 1
|
|
private IDeviceSetup SLICEHandler { get; set; }
|
|
|
|
// device type 2
|
|
private IDeviceSetup RibeyeHandler { get; set; }
|
|
|
|
// device type 3
|
|
private IDeviceSetup SLICE2Handler { get; set; }
|
|
|
|
// device type 4
|
|
private IDeviceSetup SLICE15Handler { get; set; }
|
|
|
|
// device type 6
|
|
private IDeviceSetup SLICE6Handler { get; set; }
|
|
// device type 8
|
|
private IDeviceSetup SLICE6AirHandler { get; set; }
|
|
// device type 12
|
|
private IDeviceSetup SLICE6AirBridgeHandler { get; set; }
|
|
// device type 7
|
|
private IDeviceSetup slice6dbHandler { get; set; }
|
|
// device type 9
|
|
private IDeviceSetup powerproHandler { get; set; }
|
|
// device type 10
|
|
private IDeviceSetup tsrAirHandler { get; set; }
|
|
// device type 11
|
|
private IDeviceSetup slice6db3Handler { get; set; }
|
|
|
|
// device type 12
|
|
private IDeviceSetup sliceprodbHandler { get; set; }
|
|
|
|
private IDeviceSetup SLICE6AirTcHandler { get; set; }
|
|
|
|
private string _sliceDBHostName;
|
|
public string SliceDBHostName
|
|
{
|
|
get => _sliceDBHostName;
|
|
set
|
|
{
|
|
_sliceDBHostName = value;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// we want to allow SLICE ATDs to offset their connections to avoid flooding system
|
|
/// we do this by allowing subnets to connect separately
|
|
/// this property indentifies which index among subnets the current ip address belongs to
|
|
/// </summary>
|
|
public int HandlerIndex { get; set; } = 0;
|
|
|
|
private static readonly Random _random = new Random(DateTime.Now.Millisecond);
|
|
public EthernetHandling(DASFactory _factory,
|
|
UpdateFinishedEventHandler serialUpdateFinished,
|
|
IDeviceSetup slice,
|
|
IDeviceSetup rib,
|
|
IDeviceSetup slice2,
|
|
IDeviceSetup slice15,
|
|
IDeviceSetup slice6,
|
|
IDeviceSetup slice6Air,
|
|
IDeviceSetup slice6AirBridge,
|
|
IDeviceSetup _slice6db,
|
|
IDeviceSetup _powerpro,
|
|
IDeviceSetup tsrAir,
|
|
IDeviceSetup slice6db3,
|
|
IDeviceSetup sliceprodb,
|
|
IDeviceSetup slice6AirTc,
|
|
BlockingCollection<Tuple<QueueActions, DeviceHandling>> queueActionPerDevice)
|
|
: base(_factory, serialUpdateFinished, queueActionPerDevice)
|
|
{
|
|
SLICEHandler = slice;
|
|
RibeyeHandler = rib;
|
|
SLICE2Handler = slice2;
|
|
SLICE15Handler = slice15;
|
|
SLICE6Handler = slice6;
|
|
SLICE6AirHandler = slice6Air;
|
|
SLICE6AirBridgeHandler = slice6AirBridge;
|
|
slice6dbHandler = _slice6db;
|
|
powerproHandler = _powerpro;
|
|
tsrAirHandler = tsrAir;
|
|
slice6db3Handler = slice6db3;
|
|
sliceprodbHandler = sliceprodb;
|
|
SLICE6AirTcHandler = slice6AirTc;
|
|
ConnectEthernetSliceTimeout = 60000;
|
|
ConnectEthernetRibeyeTimeout = 60000;
|
|
ConnectEthernetSlice2Timeout = 60000;
|
|
ConnectEthernetSlice15Timeout = 60000;
|
|
ConnectEthernetSlice6Timeout = (int)_factory.S6ConnectNewTimeout;
|
|
ConnectEthernetTsrAirTimeout = 60000;
|
|
ConnectEthernetSliceProDBTimeout = 60000;
|
|
factory = _factory;
|
|
}
|
|
|
|
public override void Dispose()
|
|
{
|
|
try
|
|
{
|
|
_bKillSliceDBThread.Set();
|
|
//FB18389 Set this to true to end the loop in ConnectHosts when disposing
|
|
_slicedbShouldDisconnect = true;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
//ignore
|
|
}
|
|
|
|
base.Dispose();
|
|
}
|
|
|
|
internal override bool DetachAllDevices()
|
|
{
|
|
var devicesWhereRemoved = false;
|
|
lock (ConnectedDevicesLock)
|
|
{
|
|
_slicedbCanConnect = false;
|
|
_slicedbShouldDisconnect = true;
|
|
if (null != _sock && _sock.IsConnected()) { _sock.Disconnect(); }
|
|
_slicedbCanConnectEvent.Reset();
|
|
|
|
foreach (var dev in ConnectedDevices)
|
|
{
|
|
dev.Dispose();
|
|
devicesWhereRemoved = true;
|
|
}
|
|
ConnectedDevices.Clear();
|
|
}
|
|
|
|
// let our caller know if something was removed
|
|
return devicesWhereRemoved;
|
|
}
|
|
|
|
#region Slice DB Event Listener Thread
|
|
|
|
public class DistributorMsg
|
|
{
|
|
private enum ResponseMsgPos
|
|
{
|
|
ActionPos = 0,
|
|
DevTypePos = 1,
|
|
ConnectStringPos = 2
|
|
}
|
|
|
|
const int NUMBER_OF_TOKENS = 3;
|
|
private const string CONNECT_ACTION = "hello";
|
|
private const string DISCONNECT_ACTION = "goodbye";
|
|
const string SLICE_DEV_TYPE = "slicebase";
|
|
private const string RIBEYE_DEV_TYPE = "ribeye";
|
|
private const string SLICE2_DEV_TYPE = "slice2base";
|
|
private const string SLICE_1_5_DEV_TYPE = "slice_1_5_base";
|
|
private const string SLICE_6_DEV_TYPE = "slice6base";
|
|
private const string SLICE_6_AIR_DEV_TYPE = "slice6Air";
|
|
private const string SLICE_6_AIR_BR_DEV_TYPE = "slice6_falcon";
|
|
private const string SLICE_6_AIR_TC_DEV_TYPE = "SliceTC";
|
|
private const string slice_6_db_dev_type = "slice6db";
|
|
private const string PowerPro_dev_type = "PowerPro";
|
|
private const string TSR_AIR_DEV_TYPE = "tsrair";
|
|
private const string slice_6_db_3_dev_type = "slice6db3";
|
|
private const string SLICE_PRO_DB_DEV_TYPE = "sliceprodb";
|
|
|
|
// the raw message string
|
|
public readonly string Msg;
|
|
|
|
// is this a connect message?
|
|
public bool IsConnect;
|
|
|
|
// is this a slice message?
|
|
public readonly bool IsSlice;
|
|
|
|
// is this a slice 1.5 message?
|
|
public readonly bool IsSlice15;
|
|
|
|
// is this a slice 6 message?
|
|
public readonly bool IsSlice6;
|
|
|
|
// is this a slice 6 air message?
|
|
public readonly bool IsSlice6Air;
|
|
|
|
// is this a slice 6 air-bridge ('falcon-id') message?
|
|
public readonly bool IsSlice6AirBridge;
|
|
|
|
// Is this a SLICE6 AIR-Tc message?
|
|
public bool IsSlice6AirTc;
|
|
|
|
// is this a slice 6 DB message?
|
|
public readonly bool IsSlice_6_DB;
|
|
|
|
public readonly bool IsSliceProDB;
|
|
|
|
// is this a PowerPRO message?
|
|
public bool IsPowerPro;
|
|
|
|
// is this a TSR AIR message?
|
|
public bool IsTsrAir;
|
|
|
|
public bool IsSlice_6_DB_3;
|
|
public bool IsSlice6_Family
|
|
{
|
|
get
|
|
{
|
|
//this seems awfully wrong, but I'm copying what FWTU is doing ...
|
|
//it seems wrong because the SLICEPRODb shouldn't probably be a member of the S6 family, also maybe the powerpro doesn't belong here
|
|
//for now FWTU says put it in here, but maybe this should not longer be called "Slice6 Family"?
|
|
return IsSlice6 || IsSlice6Air || IsSlice6AirBridge || IsSlice_6_DB || IsPowerPro || IsSlice_6_DB_3 || IsSliceProDB || IsSlice6AirTc;
|
|
}
|
|
}
|
|
// supports KeepAlive
|
|
public bool SupportsKeepAlive;
|
|
|
|
// is this a slice 2 message?
|
|
public readonly bool IsSlice2;
|
|
|
|
// the connect string
|
|
public readonly string ConnectString;
|
|
|
|
public DistributorMsg(string msg)
|
|
{
|
|
try
|
|
{
|
|
Msg = msg;
|
|
var tokens = Msg.Split(' ');
|
|
if (tokens.Length != NUMBER_OF_TOKENS)
|
|
{ //FB43867 applied the patch
|
|
//Check if we're connecting the command port
|
|
if (tokens.Length == 2 && tokens[0] == DASFactory.COMMAND_PORT_CONNECT_OVERRIDE_MESSAGE)
|
|
{
|
|
IsConnect = true;
|
|
IsSlice15 = true;
|
|
ConnectString = tokens[1];
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
throw new ArgumentException($"DistributorMsg: Invalid message: {Msg}");
|
|
}
|
|
}
|
|
|
|
// is it connect?
|
|
IsConnect = tokens[(int)ResponseMsgPos.ActionPos] == CONNECT_ACTION;
|
|
|
|
// is it slice?
|
|
IsSlice = tokens[(int)ResponseMsgPos.DevTypePos] == SLICE_DEV_TYPE;
|
|
|
|
// is it slice?
|
|
IsSlice15 = tokens[(int)ResponseMsgPos.DevTypePos] == SLICE_1_5_DEV_TYPE;
|
|
|
|
IsSlice6 = tokens[(int)ResponseMsgPos.DevTypePos] == SLICE_6_DEV_TYPE;
|
|
|
|
IsSlice6Air = tokens[(int)ResponseMsgPos.DevTypePos] == SLICE_6_AIR_DEV_TYPE;
|
|
|
|
IsSlice6AirBridge = tokens[(int)ResponseMsgPos.DevTypePos] == SLICE_6_AIR_BR_DEV_TYPE;
|
|
|
|
// Is it a SLICE6 AIR-Tc?
|
|
IsSlice6AirTc = tokens[(int)ResponseMsgPos.DevTypePos] == SLICE_6_AIR_TC_DEV_TYPE;
|
|
|
|
// is it slice2?
|
|
IsSlice2 = tokens[(int)ResponseMsgPos.DevTypePos] == SLICE2_DEV_TYPE;
|
|
|
|
// is it sliceDB?
|
|
IsSlice_6_DB = tokens[(int)ResponseMsgPos.DevTypePos] == slice_6_db_dev_type;
|
|
|
|
IsSlice_6_DB_3 = tokens[(int)ResponseMsgPos.DevTypePos] == slice_6_db_3_dev_type;
|
|
|
|
//is it SlicePRO DB?
|
|
IsSliceProDB = tokens[(int)ResponseMsgPos.DevTypePos] == SLICE_PRO_DB_DEV_TYPE;
|
|
|
|
// is it powerpro?
|
|
IsPowerPro = tokens[(int)ResponseMsgPos.DevTypePos] == PowerPro_dev_type;
|
|
|
|
// is it next gen tsr?
|
|
IsTsrAir = tokens[(int)ResponseMsgPos.DevTypePos] == TSR_AIR_DEV_TYPE;
|
|
|
|
SupportsKeepAlive = IsSlice6 || IsSlice6Air || IsSlice6AirBridge || IsSlice_6_DB || IsPowerPro || IsSlice_6_DB_3 || IsTsrAir || IsSliceProDB || IsSlice6AirTc;
|
|
|
|
ConnectString = tokens[(int)ResponseMsgPos.ConnectStringPos];
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
APILogger.Log("Exception in DistributorMsg", ex);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
public static bool IsValidMsg(string msg)
|
|
{
|
|
try
|
|
{
|
|
var tokens = msg.Split(' ');
|
|
if (string.IsNullOrEmpty(msg))
|
|
{
|
|
if (tokens[0] == DASFactory.COMMAND_PORT_CONNECT_OVERRIDE_MESSAGE) { return true; }
|
|
return false;
|
|
}
|
|
|
|
if (tokens.Length != NUMBER_OF_TOKENS)
|
|
{
|
|
//FB43867 applied the patch
|
|
if (tokens[0] == DASFactory.COMMAND_PORT_CONNECT_OVERRIDE_MESSAGE) { return true; }
|
|
return false;
|
|
}
|
|
if (tokens[(int)ResponseMsgPos.ActionPos] != CONNECT_ACTION &&
|
|
tokens[(int)ResponseMsgPos.ActionPos] != DISCONNECT_ACTION)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
APILogger.Log("Exception in IsValidMsg", ex);
|
|
throw;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Here we keep track of devices connected to distributors, key is SliceDB hostname
|
|
/// </summary>
|
|
private readonly Dictionary<string, List<DistributorMsg>> _connectedDBDevices = new Dictionary<string, List<DistributorMsg>>();
|
|
|
|
public bool UpdateConnectedDBDevices(string name, DistributorMsg msg)
|
|
{
|
|
try
|
|
{
|
|
if (!_connectedDBDevices.ContainsKey(name))
|
|
{
|
|
var msgtmp = new DistributorMsg(msg.Msg) { IsConnect = !msg.IsConnect };
|
|
var listtmp = new List<DistributorMsg> { msgtmp };
|
|
_connectedDBDevices.Add(name, listtmp);
|
|
}
|
|
|
|
// are we adding or removing?
|
|
if (msg.IsConnect)
|
|
{
|
|
// make sure we don't have it already
|
|
if (_connectedDBDevices[name].Contains(msg))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// no, add it
|
|
_connectedDBDevices[name].Add(msg);
|
|
}
|
|
else
|
|
{
|
|
for (var i = _connectedDBDevices[name].Count - 1; i >= 0; i--)
|
|
{
|
|
if (_connectedDBDevices[name][i].ConnectString == msg.ConnectString)
|
|
{
|
|
_connectedDBDevices[name].RemoveAt(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
// we did change something
|
|
return true;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
APILogger.Log("Exception in UpdateConnectedDBDevices", ex);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
private DistributorSocket _sock;
|
|
private readonly ManualResetEvent _bKillSliceDBThread = new ManualResetEvent(false);
|
|
/// <summary>
|
|
/// set to true once a keep alive command has been acknowledged by a Ethernet device
|
|
/// some devices will not support keep alive.
|
|
/// having keep alive alleviates the need to use the heartbeat port on S6DB, reducing CPU and I/O load
|
|
/// </summary>
|
|
public bool KeepAliveEnabled { get; set; }
|
|
/// <summary>
|
|
/// set to true once the command port has been connected, part of
|
|
/// 10947 SLICE6 don't disconnect HB port UNTIL command port is connected when using keep alive
|
|
/// </summary>
|
|
public volatile bool CommandPortConnected = false;
|
|
|
|
//FB43867 applied the patch
|
|
public volatile bool CommandPortConnectSignaled = false;
|
|
|
|
public override void ReportDisconnect(object obj)
|
|
{
|
|
factory.ReportRemoved(obj);
|
|
base.ReportDisconnect(obj);
|
|
}
|
|
private List<string> GetConnectedEthernetDeviceString(DFConstantsAndEnums.DASType dasType)
|
|
{
|
|
var list = new List<string>();
|
|
if (_connectedDBDevices == null) { return list; }
|
|
|
|
switch (dasType)
|
|
{
|
|
case DFConstantsAndEnums.DASType.ETHERNET_SLICE:
|
|
foreach (var pair in _connectedDBDevices)
|
|
{
|
|
var connectStrings = (from msg in pair.Value where msg.IsSlice select msg.ConnectString);
|
|
var enumerableConnectStrings = connectStrings as string[] ?? connectStrings.ToArray();
|
|
if (enumerableConnectStrings.Any())
|
|
{
|
|
list.AddRange(enumerableConnectStrings.ToArray());
|
|
}
|
|
}
|
|
break;
|
|
case DFConstantsAndEnums.DASType.ETHERNET_SLICE1_5:
|
|
foreach (var pair in _connectedDBDevices)
|
|
{
|
|
var connectStrings = (from msg in pair.Value where msg.IsSlice15 select msg.ConnectString);
|
|
var enumerableConnectStrings = connectStrings as string[] ?? connectStrings.ToArray();
|
|
if (enumerableConnectStrings.Any())
|
|
{
|
|
list.AddRange(enumerableConnectStrings.ToArray());
|
|
}
|
|
}
|
|
break;
|
|
case DFConstantsAndEnums.DASType.ETHERNET_SLICE2:
|
|
foreach (var pair in _connectedDBDevices)
|
|
{
|
|
var connectStrings = (from msg in pair.Value where msg.IsSlice2 select msg.ConnectString);
|
|
var enumerableConnectStrings = connectStrings as string[] ?? connectStrings.ToArray();
|
|
if (enumerableConnectStrings.Any())
|
|
{
|
|
list.AddRange(enumerableConnectStrings.ToArray());
|
|
}
|
|
}
|
|
break;
|
|
case DFConstantsAndEnums.DASType.ETHERNET_SLICE6:
|
|
{
|
|
foreach (var pair in _connectedDBDevices)
|
|
{
|
|
var connectStrings = (from msg in pair.Value where msg.IsSlice6 select msg.ConnectString);
|
|
var enumerableConnectStrings = connectStrings as string[] ?? connectStrings.ToArray();
|
|
if (enumerableConnectStrings.Any())
|
|
{
|
|
list.AddRange(enumerableConnectStrings.ToArray());
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case DFConstantsAndEnums.DASType.ETHERNET_SLICE6AIR:
|
|
{
|
|
foreach (var pair in _connectedDBDevices)
|
|
{
|
|
var connectStrings = (from msg in pair.Value where msg.IsSlice6Air select msg.ConnectString);
|
|
var enumerableConnectStrings = connectStrings as string[] ?? connectStrings.ToArray();
|
|
if (enumerableConnectStrings.Any())
|
|
{
|
|
list.AddRange(enumerableConnectStrings.ToArray());
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case DFConstantsAndEnums.DASType.ETHERNET_SLICE6AIR_BR:
|
|
{
|
|
foreach (var pair in _connectedDBDevices)
|
|
{
|
|
var connectStrings = (from msg in pair.Value where msg.IsSlice6AirBridge select msg.ConnectString);
|
|
var enumerableConnectStrings = connectStrings as string[] ?? connectStrings.ToArray();
|
|
if (enumerableConnectStrings.Any())
|
|
{
|
|
list.AddRange(enumerableConnectStrings.ToArray());
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case DFConstantsAndEnums.DASType.ETHERNET_SLICE6DB:
|
|
{
|
|
foreach (var pair in _connectedDBDevices)
|
|
{
|
|
var connectStrings = (from msg in pair.Value where msg.IsSlice_6_DB select msg.ConnectString);
|
|
var enumerableConnectStrings = connectStrings as string[] ?? connectStrings.ToArray();
|
|
if (enumerableConnectStrings.Any())
|
|
{
|
|
list.AddRange(enumerableConnectStrings.ToArray());
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case DFConstantsAndEnums.DASType.ETHERNET_POWERPRO:
|
|
{
|
|
foreach (KeyValuePair<string, List<DistributorMsg>> pair in _connectedDBDevices)
|
|
{
|
|
var connectStrings = (from msg in pair.Value where msg.IsPowerPro select msg.ConnectString);
|
|
if (connectStrings != null && connectStrings.Any())
|
|
{
|
|
list.AddRange(connectStrings.ToArray());
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case DFConstantsAndEnums.DASType.ETHERNET_TSR_AIR:
|
|
{
|
|
foreach (KeyValuePair<string, List<DistributorMsg>> pair in _connectedDBDevices)
|
|
{
|
|
var connectStrings = (from msg in pair.Value where msg.IsTsrAir select msg.ConnectString);
|
|
if (connectStrings != null && connectStrings.Any())
|
|
{
|
|
list.AddRange(connectStrings.ToArray());
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case DFConstantsAndEnums.DASType.ETHERNET_SLICE6DB3:
|
|
{
|
|
foreach (KeyValuePair<string, List<DistributorMsg>> pair in _connectedDBDevices)
|
|
{
|
|
var connectStrings = (from msg in pair.Value where msg.IsSlice_6_DB_3 select msg.ConnectString);
|
|
if (connectStrings != null && connectStrings.Any())
|
|
{
|
|
list.AddRange(connectStrings.ToArray());
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case DFConstantsAndEnums.DASType.ETHERNET_SLICEPRODB:
|
|
{
|
|
foreach (KeyValuePair<string, List<DistributorMsg>> pair in _connectedDBDevices)
|
|
{
|
|
var connectStrings = from msg in pair.Value where msg.IsSliceProDB select msg.ConnectString;
|
|
if (connectStrings != null && connectStrings.Any())
|
|
{
|
|
list.AddRange(connectStrings.ToArray());
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case DFConstantsAndEnums.DASType.ETHERNET_SLICE6AIR_TC:
|
|
{
|
|
foreach (var pair in _connectedDBDevices)
|
|
{
|
|
var connectStrings = (from msg in pair.Value where msg.IsSlice6AirTc select msg.ConnectString);
|
|
var enumerableConnectStrings = connectStrings as string[] ?? connectStrings.ToArray();
|
|
if (enumerableConnectStrings.Any())
|
|
{
|
|
list.AddRange(enumerableConnectStrings.ToArray());
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
//eliminate duplicates
|
|
for (var i = list.Count - 1; i > 0; i--)
|
|
{
|
|
var index = list.IndexOf(list[i]);
|
|
if (index < i) { list.RemoveAt(i); }
|
|
}
|
|
return list;
|
|
}
|
|
private List<string> GetConnectedEthernetDeviceSDBString(bool slice)
|
|
{
|
|
var list = new List<string>();
|
|
if (!factory.AllowSDBCommandPort) { return list; }
|
|
if (_connectedDBDevices == null)
|
|
{
|
|
return list;
|
|
}
|
|
list.AddRange(from pair in _connectedDBDevices
|
|
where !(pair.Value[0].IsSlice6 || pair.Value[0].IsSlice6Air || pair.Value[0].IsSlice6AirBridge
|
|
|| pair.Value[0].IsSlice_6_DB || pair.Value[0].IsSlice_6_DB_3
|
|
|| pair.Value[0].IsTsrAir
|
|
|| pair.Value[0].IsPowerPro
|
|
|| pair.Value[0].IsSliceProDB
|
|
|| pair.Value[0].IsSlice6AirTc)
|
|
select pair.Key into s
|
|
select s + ":8201");
|
|
return list;
|
|
}
|
|
private List<string> GetActiveConnectedEthernetDeviceStrings(bool slice)
|
|
{
|
|
var list = new List<string>();
|
|
if (_connectedDBDevices == null)
|
|
{
|
|
return list;
|
|
}
|
|
var devs = ConnectedDevices.ToArray();
|
|
foreach (var dev in devs)
|
|
{
|
|
if (!dev.Dev.Comm.Connected) { continue; }
|
|
if ((slice && dev.DasType == SLICEHandler.GetDASType()) ||
|
|
(!slice && dev.DasType == RibeyeHandler.GetDASType()) ||
|
|
(slice && dev.DasType == SLICE2Handler.GetDASType()) ||
|
|
(slice && dev.DasType == SLICE15Handler.GetDASType()) ||
|
|
(slice && dev.DasType == SLICE6Handler.GetDASType()) ||
|
|
(slice && dev.DasType == SLICE6AirHandler.GetDASType()) ||
|
|
(slice && dev.DasType == SLICE6AirBridgeHandler.GetDASType()) ||
|
|
(slice && dev.DasType == slice6dbHandler.GetDASType()) ||
|
|
(slice && dev.DasType == powerproHandler.GetDASType()) ||
|
|
(slice && dev.DasType == tsrAirHandler.GetDASType()) ||
|
|
(slice && dev.DasType == slice6db3Handler.GetDASType()) ||
|
|
(slice && dev.DasType == sliceprodbHandler.GetDASType()) ||
|
|
(slice && dev.DasType == SLICE6AirTcHandler.GetDASType())
|
|
)
|
|
{
|
|
list.Add(dev.Dev.ConnectString);
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
private List<string> GetActiveConnectedEthernetSDBDeviceStrings(bool slice)
|
|
{
|
|
var list = new List<string>();
|
|
if (!factory.AllowSDBCommandPort) { return list; }
|
|
if (_connectedDBDevices == null)
|
|
{
|
|
return list;
|
|
}
|
|
var devs = ConnectedDevices.ToArray();
|
|
list.AddRange(from dev in devs where dev.Dev.Comm.Connected where dev.DasType == DFConstantsAndEnums.DASType.SLICE_DB select dev.Dev.ConnectString);
|
|
return list;
|
|
}
|
|
|
|
#region Slice connect
|
|
|
|
private void UpdateConnectedEthernetSlices()
|
|
{
|
|
ConnectNewDevices(() => GetConnectedEthernetDeviceString(DFConstantsAndEnums.DASType.ETHERNET_SLICE),
|
|
() => GetActiveConnectedEthernetDeviceStrings(true),
|
|
() => SLICEHandler.GetICommunication(),
|
|
comm => SLICEHandler.GetIConnectedDevice(comm),
|
|
SLICEHandler.GetDASType(),
|
|
SLICEHandler,
|
|
ConnectEthernetSliceTimeout);
|
|
}
|
|
|
|
/// <summary>
|
|
/// returns all connectable devices reported by ECM/SDBs
|
|
/// the connect strings are in the form of IP:Port as reported by
|
|
/// HELLO SLICEBASE xxx.xxx.xxx.xxx:yyyy
|
|
/// 14157 Refresh/Stability Issue in Data Acquisition Tile
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public string[] GetConnectedEthernetDeviceStrings()
|
|
{
|
|
var list = new List<string>();
|
|
if (_connectedDBDevices == null) { return list.ToArray(); }
|
|
|
|
foreach (var pair in _connectedDBDevices)
|
|
{
|
|
var connectStrings = (from msg in pair.Value where msg.IsConnect select msg.ConnectString);
|
|
var enumerableConnectStrings = connectStrings as string[] ?? connectStrings.ToArray();
|
|
if (enumerableConnectStrings.Any())
|
|
{
|
|
list.AddRange(enumerableConnectStrings.ToArray());
|
|
}
|
|
}
|
|
|
|
list = list.Distinct().ToList();
|
|
|
|
return list.ToArray();
|
|
}
|
|
private void UpdateConnectedEthernetSlice2s()
|
|
{
|
|
ConnectNewDevices(() => GetConnectedEthernetDeviceString(DFConstantsAndEnums.DASType.ETHERNET_SLICE2),
|
|
() => GetActiveConnectedEthernetDeviceStrings(true),
|
|
() => SLICE2Handler.GetICommunication(),
|
|
comm => SLICE2Handler.GetIConnectedDevice(comm),
|
|
SLICE2Handler.GetDASType(),
|
|
SLICE2Handler,
|
|
ConnectEthernetSlice2Timeout);
|
|
}
|
|
|
|
private void UpdateConnectedEthernetSlice1_5s()
|
|
{
|
|
ConnectNewDevices(() => GetConnectedEthernetDeviceString(DFConstantsAndEnums.DASType.ETHERNET_SLICE1_5),
|
|
() => GetActiveConnectedEthernetDeviceStrings(true),
|
|
() => SLICE15Handler.GetICommunication(),
|
|
comm => SLICE15Handler.GetIConnectedDevice(comm),
|
|
SLICE15Handler.GetDASType(),
|
|
SLICE15Handler,
|
|
ConnectEthernetSlice15Timeout);
|
|
}
|
|
private void UpdateConnectedEthernetSlice6s()
|
|
{
|
|
ConnectNewDevices(() => GetConnectedEthernetDeviceString(DFConstantsAndEnums.DASType.ETHERNET_SLICE6),
|
|
() => GetActiveConnectedEthernetDeviceStrings(true),
|
|
() => SLICE6Handler.GetICommunication(),
|
|
comm => SLICE6Handler.GetIConnectedDevice(comm),
|
|
SLICE6Handler.GetDASType(),
|
|
SLICE6Handler,
|
|
ConnectEthernetSlice6Timeout);
|
|
}
|
|
private void UpdateConnectedEthernetSlice6Airs()
|
|
{
|
|
ConnectNewDevices(() => GetConnectedEthernetDeviceString(DFConstantsAndEnums.DASType.ETHERNET_SLICE6AIR),
|
|
() => GetActiveConnectedEthernetDeviceStrings(true),
|
|
() => SLICE6AirHandler.GetICommunication(),
|
|
comm => SLICE6AirHandler.GetIConnectedDevice(comm),
|
|
SLICE6AirHandler.GetDASType(),
|
|
SLICE6AirHandler,
|
|
ConnectEthernetSlice6Timeout);
|
|
}
|
|
private void UpdateConnectedEthernetSlice6AirBridges()
|
|
{
|
|
ConnectNewDevices(() => GetConnectedEthernetDeviceString(DFConstantsAndEnums.DASType.ETHERNET_SLICE6AIR_BR),
|
|
() => GetActiveConnectedEthernetDeviceStrings(true),
|
|
() => SLICE6AirBridgeHandler.GetICommunication(),
|
|
comm => SLICE6AirBridgeHandler.GetIConnectedDevice(comm),
|
|
SLICE6AirBridgeHandler.GetDASType(),
|
|
SLICE6AirBridgeHandler,
|
|
ConnectEthernetSlice6Timeout);
|
|
}
|
|
private void UpdateConnectedEthernetSlice6DBs()
|
|
{
|
|
ConnectNewDevices(
|
|
() => GetConnectedEthernetDeviceString(DFConstantsAndEnums.DASType.ETHERNET_SLICE6DB),
|
|
() => GetActiveConnectedEthernetDeviceStrings(true),
|
|
() => slice6dbHandler.GetICommunication(),
|
|
comm => slice6dbHandler.GetIConnectedDevice(comm),
|
|
slice6dbHandler.GetDASType(),
|
|
slice6dbHandler,
|
|
ConnectEthernetSlice6Timeout);
|
|
}
|
|
private void UpdateConnectedEthernetPowerPros()
|
|
{
|
|
ConnectNewDevices(
|
|
() => GetConnectedEthernetDeviceString(DFConstantsAndEnums.DASType.ETHERNET_POWERPRO),
|
|
() => GetActiveConnectedEthernetDeviceStrings(true),
|
|
() => powerproHandler.GetICommunication(),
|
|
comm => powerproHandler.GetIConnectedDevice(comm),
|
|
powerproHandler.GetDASType(),
|
|
powerproHandler,
|
|
ConnectEthernetSlice6Timeout);
|
|
}
|
|
private void UpdateConnectedEthernetTsrAirs()
|
|
{
|
|
ConnectNewDevices(
|
|
() => GetConnectedEthernetDeviceString(DFConstantsAndEnums.DASType.ETHERNET_TSR_AIR),
|
|
() => GetActiveConnectedEthernetDeviceStrings(true),
|
|
() => tsrAirHandler.GetICommunication(),
|
|
comm => tsrAirHandler.GetIConnectedDevice(comm),
|
|
tsrAirHandler.GetDASType(),
|
|
tsrAirHandler,
|
|
ConnectEthernetSlice6Timeout);
|
|
}
|
|
private void UpdateConnectedEthernetSlice6DB3s()
|
|
{
|
|
ConnectNewDevices(
|
|
() => GetConnectedEthernetDeviceString(DFConstantsAndEnums.DASType.ETHERNET_SLICE6DB3),
|
|
() => GetActiveConnectedEthernetDeviceStrings(true),
|
|
() => slice6db3Handler.GetICommunication(),
|
|
comm => slice6db3Handler.GetIConnectedDevice(comm),
|
|
slice6db3Handler.GetDASType(),
|
|
slice6db3Handler,
|
|
ConnectEthernetSlice6Timeout);
|
|
}
|
|
|
|
|
|
private void UpdateConnectedEthernetSliceProDBs()
|
|
{
|
|
ConnectNewDevices(
|
|
() => GetConnectedEthernetDeviceString(DFConstantsAndEnums.DASType.ETHERNET_SLICEPRODB),
|
|
() => GetActiveConnectedEthernetDeviceStrings(true),
|
|
() => sliceprodbHandler.GetICommunication(),
|
|
comm => sliceprodbHandler.GetIConnectedDevice(comm),
|
|
sliceprodbHandler.GetDASType(),
|
|
sliceprodbHandler,
|
|
ConnectEthernetSliceProDBTimeout);
|
|
}
|
|
private void UpdateConnectedEthernetSDBs()
|
|
{
|
|
ConnectNewDevices(
|
|
() => GetConnectedEthernetDeviceSDBString(true),
|
|
() => GetActiveConnectedEthernetSDBDeviceStrings(true),
|
|
() => new EthernetSliceDB(),
|
|
comm => ((EthernetSliceHandling)SLICEHandler).GetIConnectedSDBDevice(comm),
|
|
DFConstantsAndEnums.DASType.SLICE_DB,
|
|
SLICEHandler,
|
|
ConnectEthernetSliceTimeout);
|
|
}
|
|
private void UpdateConnectedEthernetSlice6AirTCs()
|
|
{
|
|
ConnectNewDevices(() => GetConnectedEthernetDeviceString(DFConstantsAndEnums.DASType.ETHERNET_SLICE6AIR_TC),
|
|
() => GetActiveConnectedEthernetDeviceStrings(true),
|
|
() => SLICE6AirTcHandler.GetICommunication(),
|
|
comm => SLICE6AirTcHandler.GetIConnectedDevice(comm),
|
|
SLICE6AirTcHandler.GetDASType(),
|
|
SLICE6AirTcHandler,
|
|
ConnectEthernetSlice6Timeout);
|
|
}
|
|
|
|
public override void UpdateConnectedDevices()
|
|
{
|
|
if (!_slicedbCanConnect)
|
|
{
|
|
//well, we were told to stop connecting (stop monitoring)
|
|
//it is okay for us to connect again now.
|
|
_slicedbCanConnect = true;
|
|
_slicedbShouldDisconnect = false;
|
|
_slicedbCanConnectEvent.Set();
|
|
//just a courtesy before we call update connected ethernet devices
|
|
Thread.Sleep(200);
|
|
}
|
|
UpdateConnectedEthernetSlices();
|
|
if (factory.AllowSDBCommandPort)
|
|
{
|
|
UpdateConnectedEthernetSDBs();
|
|
}
|
|
UpdateConnectedEthernetSlice6s();
|
|
UpdateConnectedEthernetSlice6Airs();
|
|
UpdateConnectedEthernetSlice6AirBridges();
|
|
UpdateConnectedEthernetSlice6DBs();
|
|
UpdateConnectedEthernetSlice6DB3s();
|
|
UpdateConnectedEthernetRibeyes();
|
|
UpdateConnectedEthernetSlice2s();
|
|
UpdateConnectedEthernetSlice1_5s();
|
|
UpdateConnectedEthernetPowerPros();
|
|
UpdateConnectedEthernetTsrAirs();
|
|
UpdateConnectedEthernetSliceProDBs();
|
|
UpdateConnectedEthernetSlice6AirTCs();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Slice disconnect
|
|
|
|
private void UpdateDisconnectedEthernetSlices()
|
|
{
|
|
DisconnectRemovedDevices(() => GetConnectedEthernetDeviceString(DFConstantsAndEnums.DASType.ETHERNET_SLICE),
|
|
dev => SLICEHandler.IsCorrectType(dev),
|
|
dev => SLICEHandler.GetICommunication(dev),
|
|
SLICEHandler.GetDASType(),
|
|
ConnectEthernetSliceTimeout);
|
|
}
|
|
|
|
private void UpdateDisconnectedEthernetSlice2s()
|
|
{
|
|
DisconnectRemovedDevices(() => GetConnectedEthernetDeviceString(DFConstantsAndEnums.DASType.ETHERNET_SLICE2),
|
|
dev => SLICE2Handler.IsCorrectType(dev),
|
|
dev => SLICE2Handler.GetICommunication(dev),
|
|
SLICE2Handler.GetDASType(),
|
|
ConnectEthernetSlice2Timeout);
|
|
}
|
|
|
|
private void UpdateDisconnectedEthernetSlice1_5s()
|
|
{
|
|
DisconnectRemovedDevices(() => GetConnectedEthernetDeviceString(DFConstantsAndEnums.DASType.ETHERNET_SLICE1_5),
|
|
dev => SLICE15Handler.IsCorrectType(dev),
|
|
dev => SLICE15Handler.GetICommunication(dev),
|
|
SLICE15Handler.GetDASType(),
|
|
ConnectEthernetSlice15Timeout);
|
|
}
|
|
private void UpdateDisconnectedEthernetSliceProDBs()
|
|
{
|
|
DisconnectRemovedDevices(() => GetConnectedEthernetDeviceString(DFConstantsAndEnums.DASType.ETHERNET_SLICEPRODB),
|
|
|
|
dev => sliceprodbHandler.IsCorrectType(dev),
|
|
dev => sliceprodbHandler.GetICommunication(dev),
|
|
sliceprodbHandler.GetDASType(),
|
|
ConnectEthernetSliceProDBTimeout);
|
|
}
|
|
private void UpdateDisconnectedEthernetSlice6s()
|
|
{
|
|
DisconnectRemovedDevices(() => GetConnectedEthernetDeviceString(DFConstantsAndEnums.DASType.ETHERNET_SLICE6),
|
|
|
|
dev => SLICE6Handler.IsCorrectType(dev),
|
|
dev => SLICE6Handler.GetICommunication(dev),
|
|
SLICE6Handler.GetDASType(),
|
|
ConnectEthernetSlice6Timeout);
|
|
}
|
|
private void UpdateDisconnectedEthernetSlice6Airs()
|
|
{
|
|
DisconnectRemovedDevices(() => GetConnectedEthernetDeviceString(DFConstantsAndEnums.DASType.ETHERNET_SLICE6AIR),
|
|
|
|
dev => SLICE6AirHandler.IsCorrectType(dev),
|
|
dev => SLICE6AirHandler.GetICommunication(dev),
|
|
SLICE6AirHandler.GetDASType(),
|
|
ConnectEthernetSlice6Timeout);
|
|
}
|
|
private void UpdateDisconnectedEthernetSlice6AirBridges()
|
|
{
|
|
DisconnectRemovedDevices(() => GetConnectedEthernetDeviceString(DFConstantsAndEnums.DASType.ETHERNET_SLICE6AIR_BR),
|
|
|
|
dev => SLICE6AirBridgeHandler.IsCorrectType(dev),
|
|
dev => SLICE6AirBridgeHandler.GetICommunication(dev),
|
|
SLICE6AirBridgeHandler.GetDASType(),
|
|
ConnectEthernetSlice6Timeout);
|
|
}
|
|
private void UpdateDisconnectedEthernetTsrAirs()
|
|
{
|
|
DisconnectRemovedDevices(() => GetConnectedEthernetDeviceString(DFConstantsAndEnums.DASType.ETHERNET_TSR_AIR),
|
|
|
|
dev => tsrAirHandler.IsCorrectType(dev),
|
|
dev => tsrAirHandler.GetICommunication(dev),
|
|
tsrAirHandler.GetDASType(),
|
|
ConnectEthernetSlice6Timeout);
|
|
}
|
|
private void UpdateDisconnectedEthernetSlice6AirTCs()
|
|
{
|
|
DisconnectRemovedDevices(() => GetConnectedEthernetDeviceString(DFConstantsAndEnums.DASType.ETHERNET_SLICE6AIR_TC),
|
|
|
|
dev => SLICE6AirTcHandler.IsCorrectType(dev),
|
|
dev => SLICE6AirTcHandler.GetICommunication(dev),
|
|
SLICE6AirTcHandler.GetDASType(),
|
|
ConnectEthernetSlice6Timeout);
|
|
}
|
|
public override void UpdateDisconnectedDevices()
|
|
{
|
|
UpdateDisconnectedEthernetSlices();
|
|
UpdateDisconnectedEthernetRibeyes();
|
|
UpdateDisconnectedEthernetSlice2s();
|
|
UpdateDisconnectedEthernetSlice1_5s();
|
|
UpdateDisconnectedEthernetSlice6s();
|
|
UpdateDisconnectedEthernetSlice6Airs();
|
|
UpdateDisconnectedEthernetSlice6AirBridges();
|
|
UpdateDisconnectedEthernetTsrAirs();
|
|
UpdateDisconnectedEthernetSliceProDBs();
|
|
UpdateDisconnectedEthernetSlice6AirTCs();
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Ribeye connect
|
|
|
|
private void UpdateConnectedEthernetRibeyes()
|
|
{
|
|
ConnectNewDevices(() => GetConnectedEthernetDeviceString(DFConstantsAndEnums.DASType.ETHERNET_RIBEYE),
|
|
() => GetActiveConnectedEthernetDeviceStrings(false),
|
|
() => RibeyeHandler.GetICommunication(),
|
|
comm => RibeyeHandler.GetIConnectedDevice(comm),
|
|
RibeyeHandler.GetDASType(),
|
|
RibeyeHandler,
|
|
ConnectEthernetRibeyeTimeout);
|
|
}
|
|
|
|
private void UpdateDisconnectedEthernetRibeyes()
|
|
{
|
|
DisconnectRemovedDevices(() => GetConnectedEthernetDeviceString(DFConstantsAndEnums.DASType.ETHERNET_RIBEYE),
|
|
dev => RibeyeHandler.IsCorrectType(dev),
|
|
dev => RibeyeHandler.GetICommunication(dev),
|
|
RibeyeHandler.GetDASType(),
|
|
ConnectEthernetRibeyeTimeout);
|
|
}
|
|
|
|
|
|
|
|
#endregion
|
|
|
|
private void RemoveAll()
|
|
{
|
|
_connectedDBDevices.Clear();
|
|
EnqueueConnect();
|
|
}
|
|
|
|
#endregion
|
|
|
|
public override void UpdateDeviceSetups()
|
|
{
|
|
RibeyeHandler.SetHandler(this);
|
|
SLICEHandler.SetHandler(this);
|
|
SLICE2Handler.SetHandler(this);
|
|
SLICE15Handler.SetHandler(this);
|
|
SLICE6Handler.SetHandler(this);
|
|
SLICE6AirHandler.SetHandler(this);
|
|
SLICE6AirBridgeHandler.SetHandler(this);
|
|
slice6dbHandler.SetHandler(this);
|
|
powerproHandler.SetHandler(this);
|
|
tsrAirHandler.SetHandler(this);
|
|
slice6db3Handler.SetHandler(this);
|
|
sliceprodbHandler.SetHandler(this);
|
|
SLICE6AirTcHandler.SetHandler(this);
|
|
}
|
|
}
|
|
}
|