private Task RunClient <T>(ICommonSerializer serializer, int port, Action <Poller> loadPoller, Action <T> loadProxy)
where T : class
{
var task = new Task(() =>
{
var clientContext = NetMQContext.Create();
var clientSocket = clientContext.CreateRequestSocket(); // clientContext.CreateRouterSocket();
clientSocket.Options.Linger = TimeSpan.Zero;
var clientPoller = new Poller(clientSocket);
var clientScheduler = new NetMQScheduler(clientContext, clientPoller);
var clientTransport = clientSocket.GenerateTransportSource(clientScheduler);
var clientRouter = new DefaultMessageRouter(clientTransport, serializer);
var proxy = clientRouter.AddInterface <T>();
clientSocket.Connect("tcp://localhost:" + port);
loadPoller.Invoke(clientPoller);
loadProxy.Invoke(proxy);
clientPoller.PollTillCancelled();
clientScheduler.Dispose();
clientPoller.Dispose();
clientRouter.Dispose();
clientTransport.Dispose();
clientSocket.Dispose();
clientContext.Dispose();
}, TaskCreationOptions.LongRunning);
task.Start();
return(task);
}
private Task RunServer <T>(ICommonSerializer serializer, Action <int> loadPort, Action <Poller> loadPoller, T service)
where T : class
{
var task = new Task(() =>
{
var serverContext = NetMQContext.Create();
var serverSocket = serverContext.CreateResponseSocket(); // serverContext.CreateRouterSocket();
var serverPoller = new Poller(serverSocket);
var serverScheduler = new NetMQScheduler(serverContext, serverPoller);
var serverTransport = serverSocket.GenerateTransportSource(serverScheduler);
var serverRouter = new DefaultMessageRouter(serverTransport, serializer);
serverRouter.AddService(service);
var port = serverSocket.BindRandomPort("tcp://localhost");
loadPoller.Invoke(serverPoller);
loadPort.Invoke(port);
serverPoller.PollTillCancelled();
serverScheduler.Dispose();
serverPoller.Dispose();
serverRouter.Dispose();
serverTransport.Dispose();
serverSocket.Dispose();
serverContext.Dispose();
}, TaskCreationOptions.LongRunning);
task.Start();
return(task);
}
public static Byte[] SerializeToByteArray <T>(this ICommonSerializer target, T value)
{
using (var stream = new MemoryStream())
{
target.Serialize(stream, value);
return(stream.ToArray());
}
}
public InterfaceInterceptor(ICommonWebSocket socket, ICommonSerializer serializer, string hubName)
{
_socket = socket;
_serializer = serializer;
_hubName = hubName;
_socket.Received += OnReceived;
}
public DefaultMessageRouter(ITransportSource transportSource, ICommonSerializer serializer,
IProxyObjectGenerator proxyObjectGenerator = null, IServiceWrapperGenerator serviceWrapperGenerator = null)
{
TransportSource = transportSource;
TransportSource.Received += TransportSourceOnReceived;
Serializer = serializer;
ProxyObjectGenerator = proxyObjectGenerator ?? new DefaultProxyObjectGenerator();
ServiceWrapperGenerator = serviceWrapperGenerator ?? new DefaultServiceWrapperGenerator();
}
public IMessageHandler Create(IMessageHandler handler, ICommonSerializer serializer, object service)
{
// subscribe to events on the service and forward them to the transport
// generate a method that can handle incoming messages
// it needs to send the results to the caller
// do we need to tell the servive about the caller? no. nice but not required. we can still call a method to get current state
var className = "WrapperFor" + service.GetType().Name;
var assemblies = new HashSet <string>();
foreach (var loaded in AppDomain.CurrentDomain.GetAssemblies())
{
if (!loaded.IsDynamic && loaded.FullName.StartsWith("System"))
{
assemblies.Add(loaded.Location);
}
}
var requestTypes = new List <string>();
var returnTypes = new List <Type>();
var code = GenerateClassDefinition(className, assemblies, service, requestTypes, returnTypes);
var assembly = CompileAndLoadClassDefinition(code, className, assemblies);
foreach (var rType in returnTypes.Distinct())
{
var inh = typeof(ResponseMessage <>).MakeGenericType(rType);
serializer.RegisterSubtype <Message>(inh, inh.GetHashCode());
}
foreach (var rType in assembly.GetTypes().Where(t => requestTypes.Contains(t.Name)))
{
var inh = typeof(RequestMessage <>).MakeGenericType(rType);
serializer.RegisterSubtype <Message>(inh, inh.GetHashCode());
}
var type = assembly.GetType(className);
return((IMessageHandler)Activator.CreateInstance(type, handler, serializer, service));
}
public T Create <T>(IMessageHandler handler, ICommonSerializer serializer, string serviceName)
where T : class
{
if (!typeof(T).IsInterface)
{
throw new ArgumentException("Datatype should be interface: " + typeof(T));
}
var className = "ProxyFor" + typeof(T).Name;
var assemblies = new HashSet <string>();
foreach (var loaded in AppDomain.CurrentDomain.GetAssemblies())
{
if (!loaded.IsDynamic && loaded.FullName.StartsWith("System"))
{
assemblies.Add(loaded.Location);
}
}
var requestTypes = new List <string>();
var returnTypes = new List <Type>();
var code = GenerateClassDefinition <T>(className, assemblies, requestTypes, returnTypes);
var assembly = CompileAndLoadClassDefinition(code, className, assemblies);
foreach (var rType in returnTypes.Distinct())
{
var inh = typeof(ResponseMessage <>).MakeGenericType(rType);
serializer.RegisterSubtype <Message>(inh, inh.GetHashCode());
}
foreach (var rType in assembly.GetTypes().Where(t => requestTypes.Contains(t.Name)))
{
var inh = typeof(RequestMessage <>).MakeGenericType(rType);
serializer.RegisterSubtype <Message>(inh, inh.GetHashCode());
}
var type = assembly.GetType(className);
return((T)Activator.CreateInstance(type, handler, serializer, serviceName));
}
public IMessageHandler Create(IMessageHandler handler, ICommonSerializer serializer, object service)
{
// subscribe to events on the service and forward them to the transport
// generate a method that can handle incoming messages
// it needs to send the results to the caller
// do we need to tell the servive about the caller? no. nice but not required. we can still call a method to get current state
var className = "WrapperFor" + service.GetType().Name;
var assemblies = new HashSet<string>();
foreach (var loaded in AppDomain.CurrentDomain.GetAssemblies())
if (!loaded.IsDynamic && loaded.FullName.StartsWith("System"))
assemblies.Add(loaded.Location);
var requestTypes = new List<string>();
var returnTypes = new List<Type>();
var code = GenerateClassDefinition(className, assemblies, service, requestTypes, returnTypes);
var assembly = CompileAndLoadClassDefinition(code, className, assemblies);
foreach (var rType in returnTypes.Distinct())
{
var inh = typeof(ResponseMessage<>).MakeGenericType(rType);
serializer.RegisterSubtype<Message>(inh, inh.GetHashCode());
}
foreach (var rType in assembly.GetTypes().Where(t => requestTypes.Contains(t.Name)))
{
var inh = typeof(RequestMessage<>).MakeGenericType(rType);
serializer.RegisterSubtype<Message>(inh, inh.GetHashCode());
}
var type = assembly.GetType(className);
return (IMessageHandler)Activator.CreateInstance(type, handler, serializer, service);
}
protected ProxyBase(IMessageHandler handler, ICommonSerializer serializer, string hubName)
{
_handler = handler;
_hubName = hubName;
_serializer = serializer;
}
public T Create <T>(ICommonWebSocket socket, ICommonSerializer serializer) where T : class
{
ValidateInterface(typeof(T));
return(_generator.CreateInterfaceProxyWithoutTarget <T>(new InterfaceInterceptor(socket, serializer, typeof(T).Name)));
}
