source: branches/thasling/DistributedGA/DistributedGA.Core/Implementation/WcfPeerListManager.cs @ 14253

using System;
using System.Collections.Generic;
using System.Linq;
using System.ServiceModel;
using DistributedGA.Core.Domain;
using DistributedGA.Core.Interface;
using System.Timers;
using System.Threading.Tasks;

namespace DistributedGA.Core.Implementation {
  public class WcfPeerListManager : IPeerListManager, IDisposable {

    private string serverString = null;

    private PeerInfo myself = null;

    private Timer timer = null; //sends heartbeat to contact-server

    private Object timerLock = new Object();

    private List<PeerInfo> cachedPeerList;

    private double communicationRate;

    private Random rand;

    public void Init(PeerInfo source, string contactServerUrl, double communicationRate) {
      serverString = contactServerUrl;
      this.communicationRate = communicationRate;
      myself = source;
      cachedPeerList = new List<PeerInfo>();
      rand = new Random();
      //Init
      Task.Factory.StartNew(() => RefreshPeerList(this, null), TaskCreationOptions.LongRunning);
      //Start heartbeat timer
      timer = new Timer(1000 * 30); //each 30 seconds
      timer.Elapsed += RefreshPeerList;
      timer.Start();
    }

    public List<PeerInfo> GetPeerList() {
      return cachedPeerList;
    }

    public void SendLogToServer(string msg) {
      var binding = new NetTcpBinding();
      var endpoint = new EndpointAddress(serverString);
      using (var myChannelFactory = new ChannelFactory<IContactService>(binding, endpoint)) {
        using (IClientChannel client = (IClientChannel)myChannelFactory.CreateChannel()) {
          ((IContactService)client).MakeLog(myself, msg);
        }
      }
    }

    public void Dispose() {
      timer.Stop();
      timer.Dispose();
    }

    private List<PeerInfo> ChoosePeersForMessaging(List<PeerInfo> allPeers) {
      Shuffle<PeerInfo>(allPeers);
      int toTake = Convert.ToInt32(allPeers.Count * communicationRate) + 1;
      if (allPeers.Count > 0 && toTake == 0) {
        toTake = 1;
      }
      return allPeers.Take(toTake).ToList();
    }

    private void Shuffle<T>(IList<T> list) {
      int n = list.Count;
      while (n > 1) {
        n--;
        int k = rand.Next(n + 1);
        T value = list[k];
        list[k] = list[n];
        list[n] = value;
      }
    }

    private void RefreshPeerList(object sender, ElapsedEventArgs e) {
      lock (timerLock) {
        try {
          List<PeerInfo> allPeers = new List<PeerInfo>();
          var binding = new NetTcpBinding();
          var endpoint = new EndpointAddress(serverString);
          using (var myChannelFactory = new ChannelFactory<IContactService>(binding, endpoint)) {
            using (IClientChannel client = (IClientChannel)myChannelFactory.CreateChannel()) {
              allPeers = ((IContactService)client).GetPeerList(myself);
            }
          }
          cachedPeerList = ChoosePeersForMessaging(allPeers);
        }
        catch { } //nothing to do
      }
    }

  }
}