source: branches/thasling/DistributedGA/DistributedGA.Core/Implementation/PeerNetworkMessageHandler.cs @ 13945

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using DistributedGA.Core.Domain;
using DistributedGA.Core.Interface;
using DistributedGA.Core.Util;

namespace DistributedGA.Core.Implementation {
  public class PeerNetworkMessageHandler : IMessageHandler {
    //own peer-instance Information
    private PeerInfo ownInstance = null;

    //uses peer-list from IPeerListManager to decide which peers to contact
    private IPeerListManager peerListManager;

    //uses IMessageSender to send populations to peers
    private IMessageSender sender = null;

    //provides current population for the higher layer IMigrationOperator
    //two queues are used to gather and and provide population more efficiently
    private object activeQueueLocker = new object();
    private SizedConcurrentQueue<byte[]> writeQueueOriginal;
    private SizedConcurrentQueue<byte[]> writeQueueAlternative;

    //queue for recieved items
    private SizedConcurrentQueue<byte[]> readQueue;

    //uses IMessageService for recieving population from one peer at once
    private IMessageService host = null;



    public void Init(string lanIpPrefix, string contactServerUrl) {
      try {
        ownInstance = new PeerInfo() {
          IpAddress = GetInternalIpAddress(lanIpPrefix),
          Port = 0,
          ProblemInstance = "TestProblem"
        }; // TODO: get own peerinfo

        writeQueueOriginal = new SizedConcurrentQueue<byte[]>();
        writeQueueAlternative = new SizedConcurrentQueue<byte[]>();
        readQueue = new SizedConcurrentQueue<byte[]>();
        writeQueueOriginal.Limit = 1000;
        writeQueueAlternative.Limit = 1000;
        readQueue.Limit = writeQueueOriginal.Limit;

        host = new WcfMessageService();
        ownInstance.Port = host.Init(ownInstance.IpAddress); //getting port, on which service is hostet
        host.OnDataRecieved += new EventHandler<MessageRecieveEventArgs>(OnDataRecieved);

        peerListManager = new WcfPeerListManager();
        peerListManager.Init(ownInstance, contactServerUrl);

        sender = new WcfMessageSender();
        sender.Init(ownInstance);

      }
      catch (Exception ex) {
        AddError("PeerNetworkMessageHandler.Init", ex);
      }
    }

    public void Dispose() {
      try {
        host.Dispose();
        sender.Dispose();
        peerListManager.Dispose();
      }
      catch (Exception ex) {
        AddError("PeerNetworkMessageHandler.Dispose", ex);
      }
    }

    public void PublishDataToNetwork(byte[][] data) {
      try {
        foreach (PeerInfo peer in peerListManager.GetPeerList()) {
          //maybe something will go wrong during network communication...
          try {
            sender.SendData(peer, data);
          }
          catch (Exception ex) {
            AddError("PeerNetworkMessageHandler.PublishDataToNetwork(during sending to one peer!)", ex);
          }
        }
      }
      catch (Exception ex) {
        AddError("PeerNetworkMessageHandler.PublishDataToNetwork", ex);
      }
    }

    public byte[][] GetDataFromNetwork() {
      try {
        List<byte[]> res = new List<byte[]>();
        byte[] item = null;
        lock (activeQueueLocker) {
          //changing the current queue for storing items to send
          //then read from the now unselect queue
          var tmp = writeQueueAlternative;
          writeQueueAlternative = writeQueueOriginal;
          writeQueueOriginal = tmp;
        }

        //creating resultset
        while (!writeQueueAlternative.IsEmpty) {
          if (writeQueueAlternative.TryDequeue(out item)) {
            res.Add(item);
          }
        }
        return res.ToArray();
      }
      catch (Exception ex) {
        AddError("PeerNetworkMessageHandler.GetDataFromNetwork", ex);
        return null;
      }
    }

    public PeerInfo GetPeerInfo() {
      return ownInstance;
    }

    public List<PeerInfo> GetCurrentNetwork() {
      return peerListManager.GetPeerList();
    }

    private string GetInternalIpAddress(string ipPrefix) {
      try {
        var strHostName = Dns.GetHostName();
        // Then using host name, get the IP address list..
        IPHostEntry ipEntry = Dns.GetHostEntry(strHostName);
        IPAddress[] addr = ipEntry.AddressList;

        return addr
          .Select(ip => ip.ToString())
          .First(str => str.StartsWith(ipPrefix));
      }
      catch { return null; }
    }

    private void OnDataRecieved(object sender, MessageRecieveEventArgs e) {
      if (e != null) {
        lock (activeQueueLocker) {
          foreach (byte[] item in e.data) {
            writeQueueOriginal.Enqueue(item);
          }
        }
      }
    }

    private void AddError(string source, Exception ex) {
      if (peerListManager != null) {
        try {
          peerListManager.SendLogToServer(string.Concat("Source: ", source, ", Exception: ", ex.Message));
        }
        catch { }
      }
    }

  }
}