public virtual void Setup()
{
var ctx = new Context(this, _clientConfig.Domain.Id, _hostName,
NetworkInterfaceManager.GetLocalHostAddress());
_mContext.Value = ctx;
}
//public string Property(string name, string defaultValue)
//{
// name = (name ?? string.Empty).ToLower();
// if ("host.address" == name)
// {
// return HostAddress ?? defaultValue;
// }
// else if ("host.name" == name)
// {
// return HostName ?? defaultValue;
// }
// else
// {
// return defaultValue;
// }
//}
void IProvider.Initialize()
{
try {
NetworkInterfaceManager.Refresh();
}
catch (Exception ex)
{
logger.Error(ex);
}
}
public void BasicExecutionTest()
{
// arrange
INetworkInterfaceManager manager = new NetworkInterfaceManager(new DummyConfigHandler());
// act
var actual = manager.GatherNetworkData();
// assert
Assert.IsNotNull(actual);
}
private static string GetLocalIP()
{
try
{
return(NetworkInterfaceManager.GetLocalHostAddress());
}
catch
{
return(string.Empty);
}
}
static public int constructor(IntPtr l)
{
try {
NetworkInterfaceManager o;
o = new NetworkInterfaceManager();
pushValue(l, true);
pushValue(l, o);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
public void CheckIfAtLeastOneIPWasReceived()
{
// arrange
INetworkInterfaceManager manager = new NetworkInterfaceManager(new DummyConfigHandler());
// act
var actual = manager.GatherNetworkData();
// assert
CollectionAssert.AllItemsAreUnique(actual);
CollectionAssert.AllItemsAreNotNull(actual);
CollectionAssert.IsNotEmpty(actual);
CollectionAssert.AllItemsAreInstancesOfType(actual, typeof(NetworkInterfaceData));
}
public void Notify(NetworkInterfaceManager.NetworkInterfaceStatusChangedEventArgs e)
{
var killedProcessNames = new List<string>();
var networkInterface = e.NetworkInterface;
foreach (var killerValue in _killerValues.Where(_ => _.NetworkInterface.Id == networkInterface.Id))
{
KillProcessByName(killerValue.ProcessName);
killedProcessNames.Add(killerValue.ProcessName);
}
if (killedProcessNames.Count() == 0)
{
return;
}
ProcessesKilledEvent(new ProcessesKilledEventArgs(killedProcessNames));
}
public virtual void InitializeClient(ClientConfig clientConfig)
{
_clientConfig = clientConfig ?? new ClientConfig();
_hostName = NetworkInterfaceManager.GetLocalHostName();
_statistics = new DefaultMessageStatistics();
_sender = new TcpMessageSender(_clientConfig, _statistics);
_sender.Initialize();
_factory = new MessageIdFactory();
_statusUpdateTask = new StatusUpdateTask(_statistics);
_taggedTransactions = new ConcurrentDictionary <string, ITaggedTransaction>();
// initialize domain and ip address
_factory.Initialize(_clientConfig.Domain.Id);
// start status update task
ThreadPool.QueueUserWorkItem(_statusUpdateTask.Run);
Logger.Info("Thread(StatusUpdateTask) started.");
}
public virtual void InitializeClient(ClientConfig clientConfig)
{
_mClientConfig = clientConfig ?? new ClientConfig();
_mHostName = NetworkInterfaceManager.GetLocalHostName();
_mStatistics = new DefaultMessageStatistics();
_mSender = new TcpMessageSender(_mClientConfig, _mStatistics);
_mSender.Initialize();
_mFactory = new MessageIdFactory();
_mStatusUpdateTask = new StatusUpdateTask(_mStatistics);
// initialize domain and ip address
_mFactory.Initialize(_mClientConfig.Domain.Id);
// start status update task
ThreadPool.QueueUserWorkItem(_mStatusUpdateTask.Run);
Logger.Info("Thread(StatusUpdateTask) started.");
}
public void Initialize(string domain)
{
_mDomain = domain;
if (_mIpAddress != null)
{
return;
}
byte[] bytes = NetworkInterfaceManager.GetAddressBytes();
StringBuilder sb = new StringBuilder();
foreach (byte b in bytes)
{
sb.Append(((b >> 4) & 0x0F).ToString("x"));
sb.Append((b & 0x0F).ToString("x"));
}
_mIpAddress = sb.ToString();
}
public void ChannelManagementTask(object o)
{
int count = 0;
while (true)
{
// For every 5 minutes
try
{
_messageIdFactory.SaveMark(true);
if (_mActive)
{
// 1. If TCP connection is down, try to reconnect.
if (_mActiveChannel == null || !_mActiveChannel.Connected)
{
_mClientConfig.Refresh();
serversFromRemoteConfig = _mClientConfig.Servers;
if (null != _mActiveChannel)
{
Logger.Warn("The current TCP connection to " + _mActiveChannel + " is no longer connected. Will try to re-connect to server.");
}
var channel = GetActiveConnection(_mClientConfig.Servers, serversFromRemoteConfig);
if (channel != null && channel != _mActiveChannel)
{
var lastChannel = _mActiveChannel;
_mActiveChannel = channel;
if (lastChannel != null)
{
lastChannel.Close();
}
NetworkInterfaceManager.Refresh();
}
}
// 2.If TCP connection is up, rebalance by connecting to a better CAT server, if necessary.
else
{
// Rebalance step (1): for every one hour, refresh router config from CAT server.
if (count % (CatConstants.REFRESH_ROUTER_CONFIG_INTERVAL / CatConstants.TCP_RECONNECT_INTERVAL) == 0)
{
Logger.Info("Refreshing router config from CAT server");
_mClientConfig.Refresh();
}
// Rebalance step (2): for every 10 min, forcefully re-establish TCP connection, according to latest router config
if (count % (CatConstants.TCP_REBALANCE_INTERVAL / CatConstants.TCP_RECONNECT_INTERVAL) == 0)
{
serversFromRemoteConfig = _mClientConfig.Servers;
var channel = GetActiveConnection(_mClientConfig.Servers, serversFromRemoteConfig);
if (channel != null && channel != _mActiveChannel)
{
var lastChannel = _mActiveChannel;
_mActiveChannel = channel;
if (lastChannel != null)
{
if (lastChannel.Client != null && channel.Client != null)
{
Logger.Info("Rebalancing by re-establising TCP connection. Old connection to: "
+ lastChannel.Client.RemoteEndPoint + " New connection to: " + channel.Client.RemoteEndPoint);
}
lastChannel.Close();
}
NetworkInterfaceManager.Refresh();
}
}
}
}
}
catch (Exception ex) { Cat.lastException = ex; }
finally { count++; }
Thread.Sleep(CatConstants.TCP_RECONNECT_INTERVAL);
}
}
