internal NodeGroup(RelayNodeGroupDefinition groupDefinition, RelayNodeConfig nodeConfig, ForwardingConfig forwardingConfig)
{
GroupDefinition = groupDefinition;
Activated = groupDefinition.Activated;
_clusterByRange = groupDefinition.UseIdRanges;
_forwardingConfig = forwardingConfig;
NodeSelectionHopWindowSize = groupDefinition.NodeSelectionHopWindowSize;
RelayNodeClusterDefinition myClusterDefinition = NodeManager.Instance.GetMyNodeClusterDefinition();
foreach (RelayNodeClusterDefinition clusterDefintion in groupDefinition.RelayNodeClusters)
{
NodeCluster nodeCluster = new NodeCluster(clusterDefintion, nodeConfig, this, forwardingConfig);
if (clusterDefintion == myClusterDefinition)
{
MyCluster = nodeCluster;
}
Clusters.Add(nodeCluster);
}
_nodeReselectTimerCallback = new System.Threading.TimerCallback(NodeReselectTimer_Elapsed);
if (_nodeReselectTimer == null)
{
_nodeReselectTimer = new System.Threading.Timer(_nodeReselectTimerCallback);
}
_nodeReselectTimer.Change(NodeReselectIntervalMilliseconds, NodeReselectIntervalMilliseconds);
QueueTimerCallback = new System.Threading.TimerCallback(QueueTimer_Elapsed);
if (QueueTimer == null)
{
QueueTimer = new System.Threading.Timer(QueueTimerCallback);
}
QueueTimer.Change(DequeueIntervalMilliseconds, DequeueIntervalMilliseconds);
}
internal NodeGroup(RelayNodeGroupDefinition groupDefinition, RelayNodeConfig nodeConfig, ForwardingConfig forwardingConfig)
{
GroupDefinition = groupDefinition;
Activated = groupDefinition.Activated;
_clusterByRange = groupDefinition.UseIdRanges;
_forwardingConfig = forwardingConfig;
RelayNodeClusterDefinition myClusterDefinition = NodeManager.Instance.GetMyNodeClusterDefinition();
foreach (RelayNodeClusterDefinition clusterDefintion in groupDefinition.RelayNodeClusters)
{
NodeCluster nodeCluster = new NodeCluster(clusterDefintion, nodeConfig, this, forwardingConfig);
if (clusterDefintion == myClusterDefinition)
{
MyCluster = nodeCluster;
}
Clusters.Add(nodeCluster);
}
_nodeReselectTimerCallback = new System.Threading.TimerCallback(NodeReselectTimer_Elapsed);
if (_nodeReselectTimer == null)
{
_nodeReselectTimer = new System.Threading.Timer(_nodeReselectTimerCallback);
}
_nodeReselectTimer.Change(NodeReselectIntervalMilliseconds, NodeReselectIntervalMilliseconds);
QueueTimerCallback = new System.Threading.TimerCallback(QueueTimer_Elapsed);
if (QueueTimer == null)
{
QueueTimer = new System.Threading.Timer(QueueTimerCallback);
}
QueueTimer.Change(DequeueIntervalMilliseconds, DequeueIntervalMilliseconds);
}
public SocketTransportAdapter(RelayNodeDefinition node,
RelayNodeGroupDefinition group, int chunkLength)
{
this.node = node;
this.defaultChunkLength = chunkLength;
LoadSettings(node, group);
}
public RelayNodeClusterDefinition GetMyCluster()
{
if (!lookedForCluster)
{
lock (myClusterLock)
{
if (!lookedForCluster)
{
RelayNodeGroupDefinition myGroup = GetMyGroup();
if (myGroup != null)
{
int portNumber;
List <IPAddress> addresses;
GetMyNetworkInfo(out addresses, out portNumber);
if (portNumber != 0 && addresses != null)
{
foreach (IPAddress address in addresses)
{
myCluster = myGroup.GetClusterFor(address, portNumber);
if (myCluster != null)
{
break;
}
}
}
}
lookedForCluster = true;
}
}
}
return(myCluster);
}
public void LoadSettings(RelayNodeDefinition node, RelayNodeGroupDefinition group)
{
MySpace.SocketTransport.SocketSettings newSettings = BuildSettings(group.SocketSettings);
if (newSettings.SameAs(settings)) return;
IDisposable disposableObject = null;
try
{
settings = newSettings;
socketClient = new SocketClient(node.IPEndPoint, settings);
disposableObject = asyncSocketClient;
asyncSocketClient = new AsyncSocketClient(node.IPEndPoint, new SocketPoolConfig
{
ReceiveTimeout = settings.ReceiveTimeout,
NetworkOrdered = settings.UseNetworkOrder,
ConnectTimeout = settings.ConnectTimeout,
LoanCapacity = settings.PoolSize
});
}
finally
{
if (disposableObject != null)
{
try
{
asyncSocketClient.Dispose();
}
catch (Exception ex)
{
log.Error("Failed to dispose AsyncSocketClient", ex);
}
}
}
}
private IRelayTransport _createTransportDelegate(RelayNodeDefinition nodeDefinition,
RelayNodeGroupDefinition groupDefinition)
{
var transport = new MockTransport(nodeDefinition, groupDefinition);
transport.DoDispatchMessages = true;
transport.MessageRecievedMethod = _receiveMessage;
transport.MessageListRecievedMethod = _receiveMessageList;
IRelayTransport[] otherTransports = null;
if (_createTransports != null)
{
var count = _createTransports.Length;
if (count > 0)
{
otherTransports = new IRelayTransport[count];
for (var idx = 0; idx < count; ++idx)
{
otherTransports[idx] = _createTransports[idx](
nodeDefinition, groupDefinition);
}
}
}
if (otherTransports == null)
{
return(transport);
}
var transports = new List <IRelayTransport>();
transports.AddRange(otherTransports);
transports.Add(transport);
return(new RelayTransportStack(transports.ToArray()));
}
public RelayNodeDefinition GetMyNode()
{
if (!lookedForNode)
{
lock (myNodeLock)
{
if (!lookedForNode)
{
RelayNodeGroupDefinition group = GetMyGroup();
if (group != null)
{
int portNumber;
List <IPAddress> addresses;
GetMyNetworkInfo(out addresses, out portNumber);
if (portNumber != 0 && addresses != null)
{
foreach (IPAddress address in addresses)
{
myNode = group.GetNodeFor(address, portNumber);
if (myNode != null)
{
break;
}
}
}
}
lookedForNode = true;
}
}
}
return(myNode);
}
public SocketTransportAdapter(RelayNodeDefinition node,
RelayNodeGroupDefinition group, int chunkLength)
{
this.node = node;
this.defaultChunkLength = chunkLength;
LoadSettings(node, group);
}
private void InstantiatePipelineClient(RelayNodeGroupDefinition groupDefinition)
{
var client = PipelineClient.GetClient(_ipEndPoint);
client.AckTimeout = TimeSpan.FromMilliseconds(groupDefinition.SocketSettings.ReceiveTimeout >> 1);
client.ResponseTimeout = TimeSpan.FromMilliseconds(groupDefinition.SocketSettings.ReceiveTimeout);
RelayMessageSender = new PipelineSender(client);
}
internal void ReloadMapping(RelayNodeGroupDefinition groupDefinition, RelayNodeConfig newConfig, ForwardingConfig newForwardingConfig)
{
RelayNodeClusterDefinition myClusterDefinition = newConfig.GetMyCluster();
Activated = groupDefinition.Activated;
GroupDefinition = groupDefinition;
_clusterByRange = groupDefinition.UseIdRanges;
_forwardingConfig = newForwardingConfig;
if (groupDefinition.RelayNodeClusters.Length == Clusters.Count)
{
//same number of clusters, just let the clusters rebuild themselves. the clusters will entirely rebuild, so shuffinling around servers should be okay
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Rebuilding existing clusters in group {0}.", groupDefinition.Name);
}
for (int i = 0; i < groupDefinition.RelayNodeClusters.Length; i++)
{
Clusters[i].ReloadMapping(groupDefinition.RelayNodeClusters[i], newConfig, newForwardingConfig);
if (groupDefinition.RelayNodeClusters[i] == myClusterDefinition)
{
MyCluster = Clusters[i];
}
}
if (myClusterDefinition == null && MyCluster != null)
{
if (_log.IsInfoEnabled)
{
_log.InfoFormat("Group {0} no longer contains this server. Removing.", GroupName);
}
//this group no longer contains "me". If it DID contain "me", it would've been set above.
MyCluster = null;
}
}
else
{
//build new clusters and replace the existing ones with them
if (_log.IsInfoEnabled)
{
_log.InfoFormat("Number of clusters in group {0} changed, rebuilding.", groupDefinition.Name);
}
NodeCluster myCluster = null;
List <NodeCluster> newClusters = new List <NodeCluster>();
foreach (RelayNodeClusterDefinition clusterDefintion in groupDefinition.RelayNodeClusters)
{
NodeCluster nodeCluster = new NodeCluster(clusterDefintion, newConfig, this, newForwardingConfig);
if (clusterDefintion == myClusterDefinition)
{
myCluster = nodeCluster;
}
newClusters.Add(nodeCluster);
}
Clusters = newClusters;
MyCluster = myCluster;
}
_nodeReselectTimer.Change(NodeReselectIntervalMilliseconds, NodeReselectIntervalMilliseconds);
}
/// <summary>
/// Creates a new instance of <see cref="IRelayTransport"/> for the given <see cref="RelayNodeDefinition"/>
/// and <see cref="RelayNodeGroupDefinition"/>.
/// </summary>
/// <param name="nodeDefinition">The node definition.</param>
/// <param name="group">The group.</param>
/// <param name="chunkLength">The chunk length</param>
/// <returns></returns>
internal static IRelayTransport CreateTransportForNode(RelayNodeDefinition nodeDefinition,
RelayNodeGroupDefinition group, int chunkLength)
{
CreateTransportDelegate creator = CreateTransportMethod;
if (creator == null)
{
return new SocketTransportAdapter(nodeDefinition, group, chunkLength);
}
IRelayTransport transport = creator(nodeDefinition, group) ?? new NullTransport();
return transport;
}
/// <summary>
/// Creates a new instance of <see cref="IRelayTransport"/> for the given <see cref="RelayNodeDefinition"/>
/// and <see cref="RelayNodeGroupDefinition"/>.
/// </summary>
/// <param name="nodeDefinition">The node definition.</param>
/// <param name="group">The group.</param>
/// <param name="chunkLength">The chunk length</param>
/// <returns></returns>
internal static IRelayTransport CreateTransportForNode(RelayNodeDefinition nodeDefinition,
RelayNodeGroupDefinition group, int chunkLength)
{
CreateTransportDelegate creator = CreateTransportMethod;
if (creator == null)
{
return(new SocketTransportAdapter(nodeDefinition, group, chunkLength));
}
IRelayTransport transport = creator(nodeDefinition, group) ?? new NullTransport();
return(transport);
}
/// <summary>Initializes an instance of the <see cref="MockTransport"/> class.</summary>
/// <param name="nodeDefinition">The node definition.</param>
/// <param name="groupDefinition">The group definition.</param>
public MockTransport(RelayNodeDefinition nodeDefinition,
RelayNodeGroupDefinition groupDefinition)
{
if (nodeDefinition == null)
{
throw new ArgumentNullException("nodeDefinition");
}
if (groupDefinition == null)
{
throw new ArgumentNullException("groupDefinition");
}
_node = nodeDefinition;
_group = groupDefinition;
DoDispatchMessages = true;
}
public SocketTransportSender(RelayNodeDefinition nodeDefinition, RelayNodeGroupDefinition groupDefinition)
{
if (groupDefinition.SocketSettings != null)
{
_sendTimeout = TimeSpan.FromMilliseconds(groupDefinition.SocketSettings.SendTimeout);
}
else if (groupDefinition.DefaultSocketSettings != null)
{
_sendTimeout = TimeSpan.FromMilliseconds(groupDefinition.DefaultSocketSettings.SendTimeout);
}
else
{
_sendTimeout = TimeSpan.Zero;
}
_transport = new SocketTransportAdapter(nodeDefinition, groupDefinition, 1);
}
public RelayNodeGroupDefinition GetNodeGroupForTypeId(short typeId)
{
RelayNodeGroupDefinition group = null;
if (RelayNodeMapping != null && TypeSettings != null)
{
string groupName = TypeSettings.TypeSettingCollection.GetGroupNameForId(typeId);
if (groupName != null)
{
if (RelayNodeMapping.RelayNodeGroups.Contains(groupName))
{
group = RelayNodeMapping.RelayNodeGroups[groupName];
}
}
}
return(group);
}
public RelayNodeGroupDefinition GetMyGroup()
{
if (!lookedForGroup)
{
lock (myGroupLock)
{
if (!lookedForGroup)
{
int portNumber;
List <IPAddress> addresses;
GetMyNetworkInfo(out addresses, out portNumber);
if (portNumber == 0)
{
if (log.IsInfoEnabled)
{
log.Info("This server is not listening and will act as a client.");
}
}
else if (addresses != null)
{
if (log.IsInfoEnabled)
{
log.Info("The Relay Node Mapping is looking for group containing this server.");
}
myGroup = RelayNodeMapping.RelayNodeGroups.GetGroupContaining(addresses, portNumber);
if (log.IsInfoEnabled)
{
if (myGroup != null)
{
log.InfoFormat("This server is in group {0}", myGroup.Name);
}
else
{
log.InfoFormat("This server is not in any defined groups and will act as a client.");
}
}
}
lookedForGroup = true;
}
}
}
return(myGroup);
}
private void BuildNodeGroups(RelayNodeConfig relayNodeConfig, Dictionary <string, Dictionary <string, MessageQueue> > errorQueues)
{
RelayNodeMapping relayNodeMapping = relayNodeConfig.RelayNodeMapping;
if (relayNodeMapping != null)
{
if (relayNodeMapping.Validate())
{
NodeGroupCollection nodeGroups = new NodeGroupCollection(relayNodeMapping.RelayNodeGroups, relayNodeConfig, ForwardingConfig);
NodeGroups = nodeGroups;
RelayNodeGroupDefinition myGroupDefinition = Config.GetMyGroup();
if (myGroupDefinition != null && NodeGroups.Contains(myGroupDefinition.Name))
{
MyNodeGroup = NodeGroups[myGroupDefinition.Name];
}
else
{
MyNodeGroup = null;
}
if (errorQueues != null)
{
nodeGroups.PopulateQueues(errorQueues, true);
}
}
else
{
if (_log.IsErrorEnabled)
{
_log.Error("Forwarder not loading invalid config.");
}
NodeGroups = new NodeGroupCollection();
}
}
else
{
NodeGroups = new NodeGroupCollection();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="RelayEndPoint"/> class, and presents a <see cref="IRelayMessageSender"/>.
/// </summary>
/// <param name="nodeDefinition">The node definition.</param>
/// <param name="groupDefinition">The group definition.</param>
/// <exception cref="InvalidOperationException">Thrown if the RelayNode configuration member "ServiceType" is set to an invalid value.</exception>
/// <remarks>A RelayEndPoint references either a PipelineTransport or or SocketTransport type endpoint, which is configured in the RelayNodeMapping.
/// A pipeline node will have the PipelinePort set to a nonzero value. A SocketTransport node will have the ServiceType="Sockets" and Port set
/// to a nonzero value.</remarks>
public RelayEndPoint(RelayNodeDefinition nodeDefinition, RelayNodeGroupDefinition groupDefinition)
{
var address = Dns.GetHostAddresses(nodeDefinition.Host)[0];
if (nodeDefinition.PipelinePort != 0)
{
_ipEndPoint = new IPEndPoint(address, nodeDefinition.PipelinePort);
InstantiatePipelineClient(groupDefinition);
}
else
{
if (nodeDefinition.ServiceType == "Sockets")
{
_ipEndPoint = new IPEndPoint(address, nodeDefinition.Port);
InstantiateSocketTransportClient(nodeDefinition, groupDefinition);
}
else
{
throw new InvalidOperationException(String.Format("An invalid ServiceType, {0}, was defined for Relay Node {2}/{1}.", nodeDefinition.ServiceType, nodeDefinition.Host, groupDefinition.Name));
}
}
}
/// <summary>
/// Initializes the cluster info.
/// </summary>
/// <param name="myClusterPos">My cluster pos.</param>
/// <param name="numClustersInGroup">The num clusters in group.</param>
/// <param name="myZone">My zone.</param>
private static void InitializeClusterInfo(out int myClusterPos, out int numClustersInGroup, out ushort myZone)
{
RelayNodeGroupDefinition myGroup = RelayNodeConfig.GetRelayNodeConfig().GetMyGroup();
RelayNodeClusterDefinition myCluster = RelayNodeConfig.GetRelayNodeConfig().GetMyCluster();
RelayNodeDefinition myNode = RelayNodeConfig.GetRelayNodeConfig().GetMyNode();
myZone = myNode.Zone;
numClustersInGroup = myGroup.RelayNodeClusters.Length;
myClusterPos = 0;
foreach (RelayNodeClusterDefinition cluster in myGroup.RelayNodeClusters)
{
if (cluster.RelayNodes.Length == myCluster.RelayNodes.Length &&
cluster.ContainsNode(myNode.IPAddress, myNode.Port))
{
// this cluster contains my Node
break;
}
myClusterPos++;
}
}
public void LoadSettings(RelayNodeDefinition node, RelayNodeGroupDefinition group)
{
MySpace.SocketTransport.SocketSettings newSettings = BuildSettings(group.SocketSettings);
if (newSettings.SameAs(settings))
{
return;
}
IDisposable disposableObject = null;
try
{
settings = newSettings;
socketClient = new SocketClient(node.IPEndPoint, settings);
disposableObject = asyncSocketClient;
asyncSocketClient = new AsyncSocketClient(node.IPEndPoint, new SocketPoolConfig
{
ReceiveTimeout = settings.ReceiveTimeout,
NetworkOrdered = settings.UseNetworkOrder,
ConnectTimeout = settings.ConnectTimeout,
LoanCapacity = settings.PoolSize
});
}
finally
{
if (disposableObject != null)
{
try
{
asyncSocketClient.Dispose();
}
catch (Exception ex)
{
log.Error("Failed to dispose AsyncSocketClient", ex);
}
}
}
}
private void InstantiateSocketTransportClient(RelayNodeDefinition nodeDefinition, RelayNodeGroupDefinition groupDefinition)
{
RelayMessageSender = new SocketTransportSender(nodeDefinition, groupDefinition);
}
private void _receiveMessageList(IList <RelayMessage> messages, RelayNodeDefinition nodeDefinition, RelayNodeGroupDefinition groupDefinition)
{
foreach (var component in _components)
{
component.HandleMessages(messages);
}
}
internal void ReloadMapping(RelayNodeGroupDefinition groupDefinition, RelayNodeConfig newConfig, ForwardingConfig newForwardingConfig)
{
RelayNodeClusterDefinition myClusterDefinition = newConfig.GetMyCluster();
Activated = groupDefinition.Activated;
GroupDefinition = groupDefinition;
_clusterByRange = groupDefinition.UseIdRanges;
_forwardingConfig = newForwardingConfig;
NodeSelectionHopWindowSize = groupDefinition.NodeSelectionHopWindowSize;
if (groupDefinition.RelayNodeClusters.Length == Clusters.Count)
{
//same number of clusters, just let the clusters rebuild themselves. the clusters will entirely rebuild, so shuffinling around servers should be okay
if (_log.IsInfoEnabled)
_log.InfoFormat("Rebuilding existing clusters in group {0}.", groupDefinition.Name);
for (int i = 0; i < groupDefinition.RelayNodeClusters.Length; i++)
{
Clusters[i].ReloadMapping(groupDefinition.RelayNodeClusters[i], newConfig, newForwardingConfig);
if (groupDefinition.RelayNodeClusters[i] == myClusterDefinition)
{
MyCluster = Clusters[i];
}
}
if (myClusterDefinition == null && MyCluster != null)
{
if (_log.IsInfoEnabled)
_log.InfoFormat("Group {0} no longer contains this server. Removing.", GroupName);
//this group no longer contains "me". If it DID contain "me", it would've been set above.
MyCluster = null;
}
}
else
{
//build new clusters and replace the existing ones with them
if (_log.IsInfoEnabled)
_log.InfoFormat("Number of clusters in group {0} changed, rebuilding.", groupDefinition.Name);
NodeCluster myCluster = null;
List<NodeCluster> newClusters = new List<NodeCluster>();
foreach (RelayNodeClusterDefinition clusterDefintion in groupDefinition.RelayNodeClusters)
{
NodeCluster nodeCluster = new NodeCluster(clusterDefintion, newConfig, this, newForwardingConfig);
if (clusterDefintion == myClusterDefinition)
{
myCluster = nodeCluster;
}
newClusters.Add(nodeCluster);
}
Clusters = newClusters;
MyCluster = myCluster;
}
_nodeReselectTimer.Change(NodeReselectIntervalMilliseconds, NodeReselectIntervalMilliseconds);
}
private void _receiveMessage(RelayMessage message, RelayNodeDefinition nodeDefinition, RelayNodeGroupDefinition groupDefinition)
{
foreach (var component in _components)
{
component.HandleMessage(message);
}
}
