Often times when I’m looking at playing with a new technology that it becomes extremely difficult to find a simple stripped down easy-to-use chunk of code that also walks through, in-depth, the concepts and reasoning behind the code. This particular code chunk began as I started exploring the Microsoft WCF’s P2P networking services and found a rather distinct lack of code that explained the hows and whys of building a Peer to Peer network.
P2P Basics
Ok. Low level building blocks.
First, everybody (who’s interested in P2P) should already understand the client server paradigm, if not, there are many wonderfully detailed articles to explain the details. In short we have N clients all connected to 1 server. Client A sends a message to the server, the server decides what to do, and then may or may not send a response to Client A and / or Client B, Client C… etc… In a peer to peer network on the other hand, everyone is the client, everyone is a server. Because of this, the client / server naming scheme goes away by popular vote and everyone is called a node or a peer. When a node is connected to other nodes that whole group is called a mesh (or graph, or cloud).
Now, in a pure P2P network there is no central authority to help or govern how nodes find each other to form a mesh or how meshes are initially created. Every node is connected to some number of other nodes, which are then connected to more nodes and so on. When one node wishes to communicate with another node (or nodes) the message is first passed on to the nodes that the first node knows about. These nodes in turn pass along the message on to other nodes that they know about and so on until finally everybody has seen the message.
One of the best, and probably most used, examples of a peer to peer network is the chat room. Until someone creates it, the chat room does not exist, but once it’s created people can be invited, join, and send messages that appear on everybody else’s screen. Even if the original person leaves the chat room, the room still exists as long as there are participants logged in. Once the last person leaves the chat room no longer exists.
Ping – The P2P Application
Note: I really dislike configuration files in demos or tutorials unless it’s a large application or showing how a particular aspect of a configuration file works. The fact that I can tell a static factory to build me something with a string name that corresponds to another file that somehow gets found, loaded, and happens to reference compiled type that then has a hidden class generated that implements that interface and is passed, bugs me when I’m trying to learn something.
If your going to follow along with this, your going to need .NET 3.5 installed and be running XP SP3, Vista, Win7 or Server 08. Visual Studio doesn’t hurt either.
To set up your project crack open Visual Studio and spin up a new Console Application, call it SimpleP2PExample. Once you have that open go over to the project, right click and Add Service Reference to System.ServiceModel, this allows you to use .NET’s WCF stuff in your app. You can choose to split up each class or interface into its own file or not: Up to you.
//Contract for our network. It says we can 'ping'
[ServiceContract(CallbackContract = typeof(IPing))]
public interface IPing
{
[OperationContract(IsOneWay = true)]
void Ping(string sender, string message);
}
Alright, first of all, attributes. If you don’t know what they are, then here’s the low down mouthful one line explanation:
Attributes are essentially binary metadata associated with a class, method, property or whatever that provides additional information about whatever it’s “Decorating”.
The first attribute is the service contract. Wait a second. Contracts.
In our node-talking-to-other-nodes scenario, somehow they have to know how to talk to each other, if I asked what the size of the door was and you handed me a window, I have NO idea what that means or what that represents. A contract defines exactly what I’m telling you, what I’m expecting back, how, and when.
In this case we’re defining a contract that has one operation, a method called Ping. We know that when node A talks to node B that if node A says “Hey, Ping(“MyName”, “Hello.”) to Node B that node B will know what to do with that and how to pass it along to other nodes. It’s also specifies that I don’t expect Node B to give me anything back.
Now, the implementation.
//implementation of our ping class
public class PingImplementation : IPing
{
public void Ping(string sender, string message)
{
Console.WriteLine("{0} says: {1}", sender, message);
}
}
Fairly simple, whenever we receive a ping from another node, this method will be executed.
The Peer Class
Alright, now the fun, magic, and games begin. We’re going to create a class called peer, which will contain all our service start / stop code and also hold our implementation of PingImplementation.
public class Peer
{
public string Id { get; private set; }
public IPing Channel;
public IPing Host;
public Peer(string id)
{
Id = id;
}
}
In order to identify an individual node in the network, so that we know who’s who and don’t get everything mixed up, it’s customary to have a unique Id that’s assigned to the peer. Now, we have two IPing variables, the best way to describe them would be incoming and outgoing. An instance of the PingImplementation class will go in Host since it will be receiving any incoming communication from other nodes; The Channel is used to communicate out to other nodes and is built up via a factory.
public void StartService()
{
var binding = new NetPeerTcpBinding();
binding.Security.Mode = SecurityMode.None;
var endpoint = new ServiceEndpoint(
ContractDescription.GetContract(typeof(IPing)),
binding,
new EndpointAddress("net.p2p://SimpleP2P"));
Host = new PingImplementation();
_factory = new DuplexChannelFactory(
new InstanceContext(Host),
endpoint);
var channel = _factory.CreateChannel();
((ICommunicationObject)channel).Open();
// wait until after the channel is open to allow access.
Channel = channel;
}
private DuplexChannelFactory<IPing> _factory;
This is what we will use to start the peer. This is the part where I’ve built up what could have been done in the configuration file with code instead.
Lets take it from the top. First off, we have our binding; this defines what communication protocol we are going to be using, and as this is a PeerToPeer app… we use NetPeerTcpBinding(). You’ll also notice that in the next line I set the security mode to none; this is done for simplicities sake. There’s three types of security modes, including None, Message, Transport and TransportWithMessageCredential. Its a bit beyond the scope of this post, but Message security ensures that the message was not tampered with as it was passed from peer to peer, Transport security ensures that the connection between nodes is secure, and TransportWithMessageCredential does both.
Now, our application needs an endpoint, essentially, an service endpoint is a set of information that is exposed outside of the application (in this case on the network as well) so that others can access it. The endpoint defines the address it can be reached at, the contract, and the method that should be used to communicate. In this case, we build up our endpoint by using ContractDescription.GetContract to generate a contract class off of our IPing interface, our network type binding, and an endpoint address where this endpoint can be reached.
Finally, we create a new instance of our PingImplementation class as the Host, and we create our channel factory. A DuplexChannelFactory allows for two way communication, the first parameter is the object that you want to receive incoming calls, and the endpoint is where those calls are coming from. The factory then creates the channel and a whole bunch of magical things happen.
If you’ll remember, our channel is of type IPing, the Duplex Factory performs some magic and generates a concrete implementation of your interface (it also implements ICommunicationObject, which is why you’ll sometimes see people create another interface called something like “IPingChannel : IPing, ICommunicationObject”, it does make it so that you don’t have to cast it, but for the purpose of this post it’s not necessary). Imagine that it takes your interface, implements all the methods and properties with all the cool DuplexChannel code needed to talk back and fourth, creates an instance, and returns it to you.
Finally, I call open on my channel to let the world see that my brand new channel and endpoint are ready for business.
public void StopService()
{
((ICommunicationObject)Channel).Close();
if (_factory != null)
_factory.Close();
}
Now, it’s all well and good, until your done. Then you need to close you channel and factory, this should be pretty self explanatory at this point. Remember our channel is an ICommunicationObject in addition to being a IPing object, so we cast and close, then check to see if our factory is null, and if not, close that as well.
Threading The Peer Class
Something I chose to do was make the peer threaded. This allows me to drop it into an application, in a thread, and receive and push stuff into it at my leisure. To do this I add in a:
private readonly AutoResetEvent _stopFlag = new AutoResetEvent(false);
This will allow me to block a method of the thread until I decide fire it (When I stop the peer).
public void Run()
{
Console.WriteLine("[ Starting Service ]");
StartService();
Console.WriteLine("[ Service Started ]");
_stopFlag.WaitOne();
Console.WriteLine("[ Stopping Service ]");
StopService();
Console.WriteLine("[ Service Stopped ]");
}
public void Stop()
{
_stopFlag.Set();
}
The run method embodies the lifecycle of this peer. When the peer thread starts into the run method it will start the service, wait until the stop flag is fired (when the Stop() method is called), and then stop and dispose the service.
Putting It All Together
class Program
{
static void Main(string[] args)
{
if (Process.GetProcessesByName(Process.GetCurrentProcess().ProcessName).Count() <= 1)
{
for (int i = 0; i < 4; i++)
{
Process.Start("SimpleP2PExample.exe");
}
}
new Program().Run();
}
public void Run()
{
Console.WriteLine("Starting the simple P2P demo.");
var peer = new Peer("Peer(" + Guid.NewGuid() + ")");
var peerThread = new Thread(peer.Run) {IsBackground = true};
peerThread.Start();
//wait for the server to start up.
Thread.Sleep(1000);
while (true)
{
Console.Write("Enter Something: ");
string tmp = Console.ReadLine();
if (tmp == "") break;
peer.Channel.Ping(peer.Id, tmp);
}
peer.Stop();
peerThread.Join();
}
}
From top to bottom, the Main method of the application checks to see if it’s the first one of this application to have started up, if it its, then it starts four additional processes (Note that if you called your project something other than SimpleP2PExample, you will need to replace the the string in Process.Start to be the name as the executable file your project generates).
The run method is also fairly simple, it creates a new instance of the Peer class, assigns it a GUID, creates a thread for the peer’s run method, starts up the thread and pauses to wait for the peer’s thread to start. We then enter a loop until the user presses enter without inputting any text. Any text that is put in is transmitted over the peer channel using the peer’s id and the message. Once we’ve finished, we stop the session and wait for the peerThread to exit and join back up with the main thread. We then exit.
Wrap Up
I hope this helps someone out there get a better understanding of the basic concepts of a simple Peer to Peer application. Feel free to leave feedback!