static void Main(string[] args)
{
var host = new ZyanComponentHost("ZyanDemo", 12800);
host.RegisterComponent<IHellow, HellowServer>();
Console.ReadLine();
}
public static void StartServer(TestContext ctx)
{
var serverSetup = new IpcBinaryServerProtocolSetup("OneWayTest");
ZyanHost = new ZyanComponentHost("OneWayServer", serverSetup);
ZyanHost.RegisterComponent<ISampleServer, SampleServer>();
ZyanConnection = new ZyanConnection("ipc://OneWayTest/OneWayServer");
}
public static void StartServer(TestContext ctx)
{
ZyanHost = new ZyanComponentHost("HeartbeatServer", new NullServerProtocolSetup(5678)
{
AuthenticationProvider = new JohnGaltAuthenticationProvider()
});
}
public override void Run()
{
Trace.WriteLine("Zyan.Examples.MiniChat.AzureWorkerRole entry point called", "Information");
IPEndPoint endPoint = RoleEnvironment.CurrentRoleInstance.InstanceEndpoints["MiniChat"].IPEndpoint;
TcpDuplexServerProtocolSetup protocol = new TcpDuplexServerProtocolSetup(endPoint.Port, new NicknameAuthProvider(), true);
ActiveNicknames = new List<string>();
ZyanComponentHost host = new ZyanComponentHost("MiniChat", protocol);
host.RegisterComponent<IMiniChat, Zyan.Examples.MiniChat.Server.MiniChat>(ActivationType.Singleton);
host.ClientLoggedOn += new EventHandler<LoginEventArgs>((sender, e) =>
{
Trace.WriteLine(string.Format("{0}: User '{1}' with IP {2} logged on.", e.Timestamp.ToString(), e.Identity.Name, e.ClientAddress));
ActiveNicknames.Add(e.Identity.Name);
});
host.ClientLoggedOff += new EventHandler<LoginEventArgs>((sender, e) =>
{
Trace.WriteLine(string.Format("{0}: User '{1}' with IP {2} logged off.", e.Timestamp.ToString(), e.Identity.Name, e.ClientAddress));
ActiveNicknames.Remove(e.Identity.Name);
});
while (true)
{
Thread.Sleep(10000);
Trace.WriteLine("Working", "Information");
}
}
/// <summary>
/// Creates a new instance of the ZyanDispatcher class.
/// </summary>
/// <param name="host">Component host</param>
public ZyanDispatcher(ZyanComponentHost host)
{
if (host == null)
throw new ArgumentNullException("host");
_host = host;
}
private void TestVulnerability(string hostName, string serverUrl, IServerProtocolSetup serverSetup, IClientProtocolSetup clientSetup, object payload)
{
ZyanSettings.DisableUrlRandomization = true;
using (var zyanHost = new ZyanComponentHost(hostName, serverSetup))
{
zyanHost.RegisterComponent <ISampleServer, SampleServer>(ActivationType.Singleton);
var credentials = new Hashtable
{
{ "Login", "hacker" },
{ "Password", "secret" },
{ string.Empty, payload }
};
using (var zyanConnection = new ZyanConnection(serverUrl, clientSetup))
{
var proxy = zyanConnection.CreateProxy <ISampleServer>();
AssertEx.Throws <SecurityException>(() => proxy.TestMethod(payload));
}
// should throw
AssertEx.Throws <SecurityException>(() =>
{
using (new ZyanConnection(serverUrl, clientSetup, credentials, true, true))
{
}
});
}
}
public void CallInterceptionBug()
{
using (var host = new ZyanComponentHost("FirstTestServer", 18888))
{
host.RegisterComponent <ITestService, TestService>(ActivationType.Singleton);
using (var connection = new ZyanConnection("tcp://127.0.0.1:18888/FirstTestServer")
{
CallInterceptionEnabled = true
})
{
// add a call interceptor for the TestService.TestMethod
connection.CallInterceptors.Add(CallInterceptor.For <ITestService>().Action(service => service.TestMethod(), data =>
{
data.Intercepted = true;
data.MakeRemoteCall();
data.ReturnValue = nameof(TestService);
}));
var testService = connection.CreateProxy <ITestService>(null);
var result = testService.TestMethod();
Assert.AreEqual(nameof(TestService), result);
}
}
}
public void Dispose()
{
if (_ipcBinaryHost != null)
{
_ipcBinaryHost.Dispose();
_ipcBinaryHost = null;
}
if (_tcpBinaryHost != null)
{
_tcpBinaryHost.Dispose();
_tcpBinaryHost = null;
}
if (_tcpCustomHost != null)
{
_tcpCustomHost.Dispose();
_tcpCustomHost = null;
}
if (_tcpDuplexHost != null)
{
_tcpDuplexHost.Dispose();
_tcpDuplexHost = null;
}
if (_httpCustomHost != null)
{
_httpCustomHost.Dispose();
_httpCustomHost = null;
}
}
public static void StartServer(TestContext ctx)
{
var serverSetup = new IpcBinaryServerProtocolSetup("StreamsTest");
ZyanHost = new ZyanComponentHost("SampleStreamServer", serverSetup);
ZyanHost.RegisterComponent<IStreamService, StreamService>();
ZyanConnection = new ZyanConnection("ipc://StreamsTest/SampleStreamServer");
}
public static void StartServer(TestContext ctx)
{
ZyanHost = new ZyanComponentHost("HeartbeatServer", new NullServerProtocolSetup(5678)
{
AuthenticationProvider = new JohnGaltAuthenticationProvider()
});
}
public override void Run()
{
Trace.WriteLine("Zyan.Examples.MiniChat.AzureWorkerRole entry point called", "Information");
IPEndPoint endPoint = RoleEnvironment.CurrentRoleInstance.InstanceEndpoints["MiniChat"].IPEndpoint;
TcpDuplexServerProtocolSetup protocol = new TcpDuplexServerProtocolSetup(endPoint.Port, new NicknameAuthProvider(), true);
ActiveNicknames = new List <string>();
ZyanComponentHost host = new ZyanComponentHost("MiniChat", protocol);
host.RegisterComponent <IMiniChat, Zyan.Examples.MiniChat.Server.MiniChat>(ActivationType.Singleton);
host.ClientLoggedOn += new EventHandler <LoginEventArgs>((sender, e) =>
{
Trace.WriteLine(string.Format("{0}: User '{1}' with IP {2} logged on.", e.Timestamp.ToString(), e.Identity.Name, e.ClientAddress));
ActiveNicknames.Add(e.Identity.Name);
});
host.ClientLoggedOff += new EventHandler <LoginEventArgs>((sender, e) =>
{
Trace.WriteLine(string.Format("{0}: User '{1}' with IP {2} logged off.", e.Timestamp.ToString(), e.Identity.Name, e.ClientAddress));
ActiveNicknames.Remove(e.Identity.Name);
});
while (true)
{
Thread.Sleep(10000);
Trace.WriteLine("Working", "Information");
}
}
public void RefreshRegisteredComponentsTest()
{
using (var host = new ZyanComponentHost("RefreshTest", new NullServerProtocolSetup(123)))
using (var conn = new ZyanConnection("null://NullChannel:123/RefreshTest"))
{
// this component is registered after connection is established
var componentName = Guid.NewGuid().ToString();
host.RegisterComponent <ISampleServer, SampleServer>(componentName);
try
{
// proxy cannot be created because connection doesn't know about the component
var proxy1 = conn.CreateProxy <ISampleServer>(componentName);
Assert.Fail("Component is not yet known for ZyanConnection.");
}
catch (ApplicationException)
{
}
// refresh the list of registered components and create a proxy
conn.RefreshRegisteredComponents();
var proxy2 = conn.CreateProxy <ISampleServer>(componentName);
var echoString = "Hello there";
var result = proxy2.Echo(echoString);
Assert.AreEqual(echoString, result);
}
}
private TcpSimplexServerHostEnvironment()
{
var protocol = new TcpCustomServerProtocolSetup(8085, new NullAuthenticationProvider(), true);
_host = new ZyanComponentHost("RecreateClientConnectionTestHost_TcpSimplex", protocol);
_host.RegisterComponent <ISampleServer, SampleServer>("SampleServer", ActivationType.SingleCall);
}
private TcpDuplexServerHostEnvironment()
{
var protocol = new TcpDuplexServerProtocolSetup(8092, new NullAuthenticationProvider(), true);
_host = new ZyanComponentHost("TcpExConnectionLockRegressionTestHost_TcpDuplex", protocol);
_host.RegisterComponent <ISampleServer, SampleServer>("SampleServer", ActivationType.SingleCall);
}
private TcpDuplexServerHostEnvironment()
{
var protocol = new TcpDuplexServerProtocolSetup(8088, new CustomAuthenticationProvider(), true);
_host = new ZyanComponentHost("CustomAuthenticationTestHost_TcpDuplex", protocol);
_host.RegisterComponent <ISampleServer, SampleServer>("SampleServer", ActivationType.SingleCall);
}
public static void StartServer(TestContext ctx)
{
var serverSetup = new IpcBinaryServerProtocolSetup("OneWayTest");
ZyanHost = new ZyanComponentHost("OneWayServer", serverSetup);
ZyanHost.RegisterComponent <ISampleServer, SampleServer>();
ZyanConnection = new ZyanConnection("ipc://OneWayTest/OneWayServer");
}
public static void StopServer()
{
if (ZyanHost != null)
{
ZyanHost.Dispose();
ZyanHost = null;
}
}
public void Dispose()
{
if (_host != null)
{
_host.Dispose();
_host = null;
}
}
private void Dispose(bool disposing)
{
if (disposing && host != null)
{
host.Dispose();
host = null;
}
}
public static void StartServer(TestContext ctx)
{
var serverSetup = new IpcBinaryServerProtocolSetup("StreamsTest");
ZyanHost = new ZyanComponentHost("SampleStreamServer", serverSetup);
ZyanHost.RegisterComponent <IStreamService, StreamService>();
ZyanConnection = new ZyanConnection("ipc://StreamsTest/SampleStreamServer");
}
private void Dispose(bool disposing)
{
if (disposing && host != null)
{
host.Dispose();
host = null;
}
}
public static void StartServer(TestContext ctx)
{
var serverSetup = new NullServerProtocolSetup(4321);
ZyanHost = new ZyanComponentHost("GenericServer", serverSetup);
ZyanHost.RegisterComponent <ISampleServer, SampleServer>();
ZyanConnection = new ZyanConnection("null://NullChannel:4321/GenericServer");
}
private EventServer()
{
_catalog = new ComponentCatalog();
_catalog.RegisterComponent <IEventComponentSingleton, EventComponentSingleton>(ActivationType.Singleton);
_catalog.RegisterComponent <IEventComponentSingleCall, EventComponentSingleCall>(ActivationType.SingleCall);
_catalog.RegisterComponent <ICallbackComponentSingleton, CallbackComponentSingleton>(ActivationType.Singleton);
_catalog.RegisterComponent <ICallbackComponentSingleCall, CallbackComponentSingleCall>(ActivationType.SingleCall);
_catalog.RegisterComponent <IRequestResponseCallbackSingleCall, RequestResponseCallbackSingleCall>(ActivationType.SingleCall);
_catalog.RegisterComponent <ITimerTriggeredEvent, TimerTriggeredEvent>(ActivationType.Singleton);
// Setting compression threshold to 1 byte means that all messages will be compressed.
// This setting should not be used in production code because smaller packets will grow in size.
// By default, Zyan only compresses messages larger than 64 kilobytes.
var tcpBinaryProtocol = new TcpBinaryServerProtocolSetup(8082);
tcpBinaryProtocol.AddServerSinkBeforeFormatter(new CompressionServerChannelSinkProvider(1, CompressionMethod.LZF));
_tcpBinaryHost = new ZyanComponentHost("TcpBinaryEventTest", tcpBinaryProtocol, _catalog);
var ipcBinaryProtocol = new IpcBinaryServerProtocolSetup("IpcTestServer");
ipcBinaryProtocol.AddServerSinkBeforeFormatter(new CompressionServerChannelSinkProvider(1, CompressionMethod.DeflateStream));
_ipcBinaryHost = new ZyanComponentHost("IpcBinaryEventTest", ipcBinaryProtocol, _catalog);
var tcpCustomProtocol = new TcpCustomServerProtocolSetup(8083, new NullAuthenticationProvider(), true)
{
CompressionThreshold = 1,
CompressionMethod = CompressionMethod.DeflateStream
};
_tcpCustomHost = new ZyanComponentHost("TcpCustomEventTest", tcpCustomProtocol, _catalog);
var tcpDuplexProtocol = new TcpDuplexServerProtocolSetup(8084, new NullAuthenticationProvider(), true)
{
CompressionThreshold = 1,
CompressionMethod = CompressionMethod.DeflateStream
};
tcpDuplexProtocol.AddChannelSetting("bindTo", "127.0.0.1");
_tcpDuplexHost = new ZyanComponentHost("TcpDuplexEventTest", tcpDuplexProtocol, _catalog);
var httpCustomProtocol = new HttpCustomServerProtocolSetup(8085, new NullAuthenticationProvider(), true)
{
CompressionThreshold = 1,
CompressionMethod = CompressionMethod.LZF
};
_httpCustomHost = new ZyanComponentHost("HttpCustomEventTest", httpCustomProtocol, _catalog);
var nullChannelProtocol = new NullServerProtocolSetup(1234);
_nullChannelHost = new ZyanComponentHost("NullEventTest", nullChannelProtocol, _catalog);
// use legacy blocking events mode because we check the handlers synchronously
ZyanSettings.LegacyBlockingEvents = true;
ZyanSettings.LegacyBlockingSubscriptions = true;
}
/// <summary>
/// Konstruktor.
/// </summary>
/// <param name="host">Komponentenhost</param>
public ZyanDispatcher(ZyanComponentHost host)
{
// Wenn kein Komponentenhost übergeben wurde ...
if (host == null)
// Ausnahme werfen
throw new ArgumentNullException("host");
// Host übernehmen
_host = host;
}
public static void Main(string[] args)
{
var protocol = new TcpDuplexServerProtocolSetup(12345, new NullAuthenticationProvider(), true);
using (var host = new ZyanComponentHost("Sample", protocol))
{
host.RegisterComponent<ISampleService, SampleService>();
Console.WriteLine("Server started. Press Enter to exit.");
Console.ReadLine();
}
}
private TcpSimplexServerHostEnvironment()
{
// use custom SRP parameters
var accounts = new SampleAccountRepository(CustomSrpParameters);
var provider = new SrpAuthenticationProvider(accounts, CustomSrpParameters);
var protocol = new TcpCustomServerProtocolSetup(8091, provider, true);
_host = new ZyanComponentHost("CustomAuthenticationTestHost_TcpSimplex", protocol);
_host.RegisterComponent <ISampleServer, SampleServer>("SampleServer", ActivationType.SingleCall);
}
public static void Main(string[] args)
{
var protocol = new TcpDuplexServerProtocolSetup(12345, new NullAuthenticationProvider(), true);
using (var host = new ZyanComponentHost("Sample", protocol))
{
host.RegisterComponent <ISampleService, SampleService>();
Console.WriteLine("Server started. Press Enter to exit.");
Console.ReadLine();
}
}
public static void StartServer(TestContext ctx)
{
ZyanComponentHost.LegacyBlockingEvents = true;
var serverSetup = new NullServerProtocolSetup(4567);
ZyanHost = new ZyanComponentHost("EventFilterServer", serverSetup);
ZyanHost.RegisterComponent <ISampleServer, SampleServer>(ActivationType.Singleton);
ZyanConnection = new ZyanConnection("null://NullChannel:4567/EventFilterServer");
}
public static void StartServer(TestContext ctx)
{
ZyanConnection.AllowUrlRandomization = false;
var serverSetup = new IpcBinaryServerProtocolSetup("ZyanProxyTest");
ZyanHost = new ZyanComponentHost("ZyanProxyServer", serverSetup);
ZyanHost.RegisterComponent<ISampleServer, SampleServer>(ActivationType.Singleton);
var clientSetup = new IpcBinaryClientProtocolSetup();
ZyanConnection = new ZyanConnection("ipc://ZyanProxyTest/ZyanProxyServer", clientSetup);
}
public static void StartServer(TestContext ctx)
{
ZyanComponentHost.LegacyBlockingEvents = true;
var serverSetup = new NullServerProtocolSetup(3456);
ZyanHost = new ZyanComponentHost("CallInterceptorServer", serverSetup);
ZyanHost.RegisterComponent <IInterceptableComponent, InterceptableComponent>(ActivationType.Singleton);
ZyanConnection = new ZyanConnection("null://NullChannel:3456/CallInterceptorServer");
ZyanConnection.CallInterceptionEnabled = true;
}
static void Main(string[] args)
{
var protocol = new TcpDuplexServerProtocolSetup(8081,null,true);
using (var host = new ZyanComponentHost("WhisperChat", protocol))
{
host.RegisterComponent<IWhisperChatService, WhisperChatService>(ActivationType.SingleCall);
Console.WriteLine("Server running.");
Console.ReadLine();
}
}
private EventServer()
{
//TcpCustomServerProtocolSetup protocol = new TcpCustomServerProtocolSetup(8083, new NullAuthenticationProvider(), true);
MsmqServerProtocolSetup protocol = new MsmqServerProtocolSetup(@"private$\reqchannel");
_host = new ZyanComponentHost("EventTest", protocol);
_host.RegisterComponent <IEventComponentSingleton, EventComponentSingleton>(ActivationType.Singleton);
_host.RegisterComponent <IEventComponentSingleCall, EventComponentSingleCall>(ActivationType.SingleCall);
_host.RegisterComponent <ICallbackComponentSingleton, CallbackComponentSingleton>(ActivationType.Singleton);
_host.RegisterComponent <ICallbackComponentSingleCall, CallbackComponentSingleCall>(ActivationType.SingleCall);
_host.RegisterComponent <IRequestResponseCallbackSingleCall, RequestResponseCallbackSingleCall>(ActivationType.SingleCall);
}
static void Main(string[] args)
{
var protocol = new TcpDuplexServerProtocolSetup(8081, null, true);
using (var host = new ZyanComponentHost("WhisperChat", protocol))
{
host.RegisterComponent <IWhisperChatService, WhisperChatService>(ActivationType.SingleCall);
Console.WriteLine("Server running.");
Console.ReadLine();
}
}
static void Main(string[] args)
{
HttpCustomServerProtocolSetup protocol = new HttpCustomServerProtocolSetup(8081, new BasicWindowsAuthProvider(), true);
using (ZyanComponentHost host = new ZyanComponentHost("EbcCalc", protocol))
{
host.SessionManager.SessionAgeLimit = 2;
host.RegisterComponent<ICalculator, Calculator>();
Console.ReadLine();
}
}
public static void StartServer(TestContext ctx)
{
var serverSetup = new IpcBinaryServerProtocolSetup("MefClientTest");
ZyanHost = new ZyanComponentHost("MefClientServer", serverSetup);
ZyanHost.RegisterComponent <IMefClientSample, MefClientSample>();
ZyanHost.RegisterComponent <IMefClientSample, MefClientSample2>("AnotherComponent");
ZyanConnection = new ZyanConnection("ipc://MefClientTest/MefClientServer");
MefCatalog = new ZyanCatalog(ZyanConnection);
MefContainer = new CompositionContainer(MefCatalog);
}
public static void StartServer(TestContext ctx)
{
ZyanConnection.AllowUrlRandomization = false;
var serverSetup = new IpcBinaryServerProtocolSetup("ZyanProxyTest");
ZyanHost = new ZyanComponentHost("ZyanProxyServer", serverSetup);
ZyanHost.RegisterComponent <ISampleServer, SampleServer>(ActivationType.Singleton);
var clientSetup = new IpcBinaryClientProtocolSetup();
ZyanConnection = new ZyanConnection("ipc://ZyanProxyTest/ZyanProxyServer", clientSetup);
}
public static void StartServer(TestContext ctx)
{
var serverSetup = new NullServerProtocolSetup(1234);
ZyanHost = new ZyanComponentHost("DuckTypingServer", serverSetup);
// registration-time check
ZyanHost.RegisterComponent<IDuck, Platypus>("Platypus");
// invocation-time check (object factory can't be verified during registration)
ZyanHost.RegisterComponent<IDuck>("Chicken", () => new Chicken());
ZyanConnection = new ZyanConnection("null://NullChannel:1234/DuckTypingServer");
}
static void Main(string[] args)
{
HttpCustomServerProtocolSetup protocol = new HttpCustomServerProtocolSetup(8081, new BasicWindowsAuthProvider(), true);
using (ZyanComponentHost host = new ZyanComponentHost("EbcCalc", protocol))
{
host.SessionManager.SessionAgeLimit = 2;
host.RegisterComponent <ICalculator, Calculator>();
Console.ReadLine();
}
}
public void CreateDisposeAndRecreateComponentHostForTcpSimplexChannel()
{
var protocol = new TcpCustomServerProtocolSetup(8087, new NullAuthenticationProvider(), true);
using (var host = new ZyanComponentHost("RecreateClientConnectionTestHost_TcpSimplex", protocol))
{
host.RegisterComponent<ISampleServer, SampleServer>("SampleServer", ActivationType.SingleCall);
}
using (var host = new ZyanComponentHost("RecreateClientConnectionTestHost_TcpSimplex", protocol))
{
host.RegisterComponent<ISampleServer, SampleServer>("SampleServer", ActivationType.SingleCall);
}
}
static void Main(string[] args)
{
using (var host = new ZyanComponentHost(Settings.Default.ServiceUri, Settings.Default.TcpPort))
{
// queryable service
host.RegisterComponent <ISampleSource, SampleSource>();
// buggy service (to demonstrate error handling)
host.RegisterComponent <INamedService, BuggyService>("BuggyService");
Console.WriteLine("Linq server started. Press ENTER to quit.");
Console.ReadLine();
}
}
public void CreateDisposeAndRecreateComponentHostForTcpSimplexChannel()
{
var protocol = new TcpCustomServerProtocolSetup(8087, new NullAuthenticationProvider(), true);
using (var host = new ZyanComponentHost("RecreateClientConnectionTestHost_TcpSimplex", protocol))
{
host.RegisterComponent <ISampleServer, SampleServer>("SampleServer", ActivationType.SingleCall);
}
using (var host = new ZyanComponentHost("RecreateClientConnectionTestHost_TcpSimplex", protocol))
{
host.RegisterComponent <ISampleServer, SampleServer>("SampleServer", ActivationType.SingleCall);
}
}
public static void StartServer(TestContext ctx)
{
var serverSetup = new NullServerProtocolSetup(1234);
ZyanHost = new ZyanComponentHost("DuckTypingServer", serverSetup);
// registration-time check
ZyanHost.RegisterComponent <IDuck, Platypus>("Platypus");
// invocation-time check (object factory can't be verified during registration)
ZyanHost.RegisterComponent <IDuck>("Chicken", () => new Chicken());
ZyanConnection = new ZyanConnection("null://NullChannel:1234/DuckTypingServer");
}
static void Main(string[] args)
{
using (var transport = new WcfServerTransportAdapter() { BaseAddress = "net.tcp://localhost:9091" })
{
var protocol = ServerProtocolSetup.WithChannel(x => transport);
using (var host = new ZyanComponentHost("HelloWcf", protocol))
{
host.RegisterComponent<IEchoService, EchoService>();
Console.WriteLine("Server läuft!");
Console.ReadLine();
}
}
}
private void RegisterComponent(int port, string name, RemoteMonitor instance)
{
TcpDuplexServerProtocolSetup protocol = new TcpDuplexServerProtocolSetup(port);
_znHost = new ZyanComponentHost(name, protocol);
//_znHost.EnableDiscovery();
//_znHost.RegisterComponent<IMonitor, RemoteMonitor>(ActivationType.Singleton);
_znHost.RegisterComponent <IMonitor, RemoteMonitor>(instance);
_znHost.ClientLoggedOn += ClientLoggedOn;
_znHost.ClientLoggedOff += ClientLoggedOff;
Builder.Output(string.Format(ClassName + ": registrado componente {0} en puerto {1}.", name, port), TraceEventType.Verbose);
}
public static void StartServer(TestContext ctx)
{
var serverSetup = new NullServerProtocolSetup(5432);
ZyanHost = new ZyanComponentHost("SampleQueryableServer", serverSetup);
ZyanHost.RegisterComponent <ISampleService, SampleService>();
ZyanHost.RegisterComponent <IObjectSource, SampleObjectSource>(new SampleObjectSource(new[] { "Hello", "World!" }));
ZyanHost.RegisterComponent <IObjectSource, SampleObjectSource>("Sample1", new SampleObjectSource(new[] { "this", "is", "an", "example" }));
ZyanHost.RegisterComponent <IObjectSource, SampleObjectSource>("Sample6");
ZyanHost.RegisterComponent <IObjectSource, SampleObjectSource>("Sample7", ActivationType.SingleCall);
ZyanHost.RegisterComponent <IEntitySource, DataWrapper>("DbSample", new DataWrapper());
ZyanConnection = new ZyanConnection("null://NullChannel:5432/SampleQueryableServer");
}
private static ZyanComponentHost CreateZyanHost(int port, string name)
{
ZyanSettings.LegacyBlockingEvents = true;
ZyanSettings.LegacyBlockingSubscriptions = true;
ZyanSettings.LegacyUnprotectedEventHandlers = true;
var serverSetup = new NullServerProtocolSetup(port);
var zyanHost = new ZyanComponentHost(name, serverSetup); //, DummySessionManager);
zyanHost.RegisterComponent <ISampleServer, SampleServer <int> >("Singleton", ActivationType.Singleton);
zyanHost.RegisterComponent <ISampleServer, SampleServer <short> >("Singleton2", ActivationType.Singleton);
zyanHost.RegisterComponent <ISampleServer, SampleServer <long> >("Singleton3", ActivationType.Singleton);
zyanHost.RegisterComponent <ISampleServer, SampleServer <byte> >("SingleCall", ActivationType.SingleCall);
zyanHost.RegisterComponent <ISampleServer, SampleServer <char> >("SingletonExternal", new SampleServer <char>());
return(zyanHost);
}
static void Main(string[] args)
{
// create a new Zyan ComponentHost
using (var host = new ZyanComponentHost("DynamicEbcResponses", 4567))
{
// register the service implementation by its interface
host.RegisterComponent<IService>(
() => new Service(),
ActivationType.SingleCall
);
// print information and keep server process running
Console.WriteLine("Stated Zyan Server on localhost:4567, press any key to stop.");
Console.ReadKey();
}
}
public void ExternalComponentCatalog_IsNotDisposed()
{
var disposed = false;
var server = new ReleasableComponent { Handler = () => disposed = true };
Assert.IsFalse(disposed);
var serverSetup = new IpcBinaryServerProtocolSetup("CleanupTest2");
using (var catalog = new ComponentCatalog())
using (var host = new ZyanComponentHost("SampleServer2", serverSetup, new InProcSessionManager(), catalog))
{
host.RegisterComponent<ISampleComponent, ReleasableComponent>(
server, s => ((ReleasableComponent)s).Release());
Assert.IsFalse(disposed);
server.Release();
Assert.IsTrue(disposed);
}
}
public override void Publish()
{
// Create the QueryHandler
IQueryHandler queryHandler = new ZyanObjectQueryHandler(ObjectSource);
#region Start the WCF server
#if !MONO
var wcfServer = new ServerQueryWcfHandler(queryHandler);
var binding = ServiceHelper.GetDefaultBinding();
string serviceUri = ServiceHelper.GetServiceUri(null, null, Artefacts.ServiceConstants.ObjectsServiceName);
wcfServer.Start(binding, serviceUri);
#endif
#endregion
#region Start the Zyan server
// change service name to avoid conflict with Remoting service
var serviceName = Artefacts.ServiceConstants.ZyanServicePrefix + Artefacts.ServiceConstants.ObjectsServiceName;
var protocol = ZyanConstants.GetDefaultServerProtocol(ZyanConstants.DefaultServicePort);
var host = new ZyanComponentHost(serviceName, protocol);
host.RegisterQueryHandler(queryHandler);
#endregion
#region Start the remoting server
var remotingServer = new ServerQueryRemotingHandlerObjects(queryHandler);
// Register default channel for remote access
Hashtable properties = new Hashtable();
properties["name"] = Artefacts.ServiceConstants.ObjectsServiceName;
properties["port"] = Artefacts.ServiceConstants.ObjectsPort;
IChannel currentChannel = RemotingConstants.GetDefaultChannel(properties);
ChannelServices.RegisterChannel(currentChannel, false);
remotingServer.Start(Artefacts.ServiceConstants.ObjectsServiceName, false);
#endregion
}
static void Main(string[] args)
{
ActiveNicknames = new List<string>();
TcpDuplexServerProtocolSetup protocol = new TcpDuplexServerProtocolSetup(Properties.Settings.Default.TcpPort, new NicknameAuthProvider(), true);
using (ZyanComponentHost host = new ZyanComponentHost("MiniChat", protocol))
{
host.PollingEventTracingEnabled = true;
host.ClientHeartbeatReceived += new EventHandler<ClientHeartbeatEventArgs>(host_ClientHeartbeatReceived);
host.RegisterComponent<IMiniChat, MiniChat>(ActivationType.Singleton);
host.ClientLoggedOn += new EventHandler<LoginEventArgs>((sender, e) =>
{
Console.WriteLine(string.Format("{0}: User '{1}' with IP {2} logged on.", e.Timestamp.ToString(), e.Identity.Name, e.ClientAddress));
ActiveNicknames.Add(e.Identity.Name);
});
host.ClientLoggedOff += new EventHandler<LoginEventArgs>((sender, e) =>
{
Console.WriteLine(string.Format("{0}: User '{1}' with IP {2} logged off.", e.Timestamp.ToString(), e.Identity.Name, e.ClientAddress));
ActiveNicknames.Remove(e.Identity.Name);
});
host.ClientSessionTerminated += new EventHandler<LoginEventArgs>((sender, e) =>
{
Console.WriteLine(string.Format("{0}: User '{1}' with IP {2} was kicked due to inactivity.", e.Timestamp.ToString(), e.Identity.Name, e.ClientAddress));
ActiveNicknames.Remove(e.Identity.Name);
});
host.EnableDiscovery();
Console.WriteLine("Chat server started. Press Enter to exit.");
Console.ReadLine();
}
}
public void Dispose()
{
if (_host != null)
{
_host.Dispose();
_host = null;
}
}
private EventServer()
{
//TcpCustomServerProtocolSetup protocol = new TcpCustomServerProtocolSetup(8083, new NullAuthenticationProvider(), true);
MsmqServerProtocolSetup protocol = new MsmqServerProtocolSetup(@"private$\reqchannel");
_host = new ZyanComponentHost("EventTest", protocol);
_host.RegisterComponent<IEventComponentSingleton, EventComponentSingleton>(ActivationType.Singleton);
_host.RegisterComponent<IEventComponentSingleCall, EventComponentSingleCall>(ActivationType.SingleCall);
_host.RegisterComponent<ICallbackComponentSingleton, CallbackComponentSingleton>(ActivationType.Singleton);
_host.RegisterComponent<ICallbackComponentSingleCall, CallbackComponentSingleCall>(ActivationType.SingleCall);
_host.RegisterComponent<IRequestResponseCallbackSingleCall, RequestResponseCallbackSingleCall>(ActivationType.SingleCall);
}
private EventServer()
{
_catalog = new ComponentCatalog();
_catalog.RegisterComponent<IEventComponentSingleton, EventComponentSingleton>(ActivationType.Singleton);
_catalog.RegisterComponent<IEventComponentSingleCall, EventComponentSingleCall>(ActivationType.SingleCall);
_catalog.RegisterComponent<ICallbackComponentSingleton, CallbackComponentSingleton>(ActivationType.Singleton);
_catalog.RegisterComponent<ICallbackComponentSingleCall, CallbackComponentSingleCall>(ActivationType.SingleCall);
_catalog.RegisterComponent<IRequestResponseCallbackSingleCall, RequestResponseCallbackSingleCall>(ActivationType.SingleCall);
_catalog.RegisterComponent<ITimerTriggeredEvent, TimerTriggeredEvent>(ActivationType.Singleton);
// Setting compression threshold to 1 byte means that all messages will be compressed.
// This setting should not be used in production code because smaller packets will grow in size.
// By default, Zyan only compresses messages larger than 64 kilobytes.
var tcpBinaryProtocol = new TcpBinaryServerProtocolSetup(8082);
tcpBinaryProtocol.AddServerSinkBeforeFormatter(new CompressionServerChannelSinkProvider(1, CompressionMethod.LZF));
_tcpBinaryHost = new ZyanComponentHost("TcpBinaryEventTest", tcpBinaryProtocol, _catalog);
var ipcBinaryProtocol = new IpcBinaryServerProtocolSetup("IpcTestServer");
ipcBinaryProtocol.AddServerSinkBeforeFormatter(new CompressionServerChannelSinkProvider(1, CompressionMethod.DeflateStream));
_ipcBinaryHost = new ZyanComponentHost("IpcBinaryEventTest", ipcBinaryProtocol, _catalog);
var tcpCustomProtocol = new TcpCustomServerProtocolSetup(8083, new NullAuthenticationProvider(), true)
{
CompressionThreshold = 1,
CompressionMethod = CompressionMethod.DeflateStream
};
_tcpCustomHost = new ZyanComponentHost("TcpCustomEventTest", tcpCustomProtocol, _catalog);
var tcpDuplexProtocol = new TcpDuplexServerProtocolSetup(8084, new NullAuthenticationProvider(), true)
{
CompressionThreshold = 1,
CompressionMethod = CompressionMethod.DeflateStream
};
tcpDuplexProtocol.AddChannelSetting("bindTo", "127.0.0.1");
_tcpDuplexHost = new ZyanComponentHost("TcpDuplexEventTest", tcpDuplexProtocol, _catalog);
var httpCustomProtocol = new HttpCustomServerProtocolSetup(8085, new NullAuthenticationProvider(), true)
{
CompressionThreshold = 1,
CompressionMethod = CompressionMethod.LZF
};
_httpCustomHost = new ZyanComponentHost("HttpCustomEventTest", httpCustomProtocol, _catalog);
var nullChannelProtocol = new NullServerProtocolSetup(1234);
_nullChannelHost = new ZyanComponentHost("NullEventTest", nullChannelProtocol, _catalog);
// use legacy blocking events mode because we check the handlers synchronously
ZyanComponentHost.LegacyBlockingEvents = true;
}
internal ZyanMessageServer(IMessageReceiver messageReceiver, int port)
{
receiver = (MessageReceiver)messageReceiver;
host = new ZyanComponentHost("OrderService", port);
}
public static void StartServer(TestContext ctx)
{
ZyanComponentHost.LegacyBlockingEvents = true;
var serverSetup = new NullServerProtocolSetup(2345);
ZyanHost = new ZyanComponentHost("EventsServer", serverSetup);
ZyanHost.RegisterComponent<ISampleServer, SampleServer>("Singleton", ActivationType.Singleton);
ZyanHost.RegisterComponent<ISampleServer, SampleServer>("SingleCall", ActivationType.SingleCall);
ZyanConnection = new ZyanConnection("null://NullChannel:2345/EventsServer");
}
public void OwnedComponentCatalog_IsDisposed()
{
var disposed = false;
var server = new ReleasableComponent { Handler = () => disposed = true };
Assert.IsFalse(disposed);
var serverSetup = new IpcBinaryServerProtocolSetup("CleanupTest1");
using (var host = new ZyanComponentHost("SampleServer1", serverSetup))
{
host.RegisterComponent<ISampleComponent, ReleasableComponent>(
server, s => ((ReleasableComponent)s).Release());
}
Assert.IsTrue(disposed);
}
public void Dispose()
{
if (_ipcBinaryHost != null)
{
_ipcBinaryHost.Dispose();
_ipcBinaryHost = null;
}
if (_tcpBinaryHost != null)
{
_tcpBinaryHost.Dispose();
_tcpBinaryHost = null;
}
if (_tcpCustomHost != null)
{
_tcpCustomHost.Dispose();
_tcpCustomHost = null;
}
if (_tcpDuplexHost != null)
{
_tcpDuplexHost.Dispose();
_tcpDuplexHost = null;
}
if (_httpCustomHost != null)
{
_httpCustomHost.Dispose();
_httpCustomHost = null;
}
}
public void TestGenericWrapperOverZyan()
{
var serverProto = new IpcBinaryServerProtocolSetup("Test");
var clientProto = new IpcBinaryClientProtocolSetup();
var host = new ZyanComponentHost("TestServer", serverProto);
host.RegisterComponent<INonGenericInterface>(() => new NonGenericWrapper(new GenericClass()), ActivationType.Singleton);
var conn = new ZyanConnection("ipc://Test/TestServer");
var proxy = conn.CreateProxy<INonGenericInterface>();
// same as usual
var test = new GenericWrapper(proxy);
var prioritySet = false;
// GetDefault
Assert.AreEqual(default(int), test.GetDefault<int>());
Assert.AreEqual(default(string), test.GetDefault<string>());
Assert.AreEqual(default(Guid), test.GetDefault<Guid>());
// Equals
Assert.IsTrue(test.Equals(123, 123));
Assert.IsFalse(test.Equals("Some", null));
// GetVersion
Assert.AreEqual("DoSomething wasn't called yet", test.GetVersion());
// DoSomething
test.DoSomething(123, 'x', "y");
Assert.AreEqual("DoSomething: A = 123, B = x, C = y", test.GetVersion());
// Compute
var dt = test.Compute<Guid, DateTime>(Guid.Empty, 123, "123");
Assert.AreEqual(default(DateTime), dt);
// CreateGuid
var guid = test.CreateGuid(dt, 12345);
Assert.AreEqual("00003039-0001-0001-0000-000000000000", guid.ToString());
// LastDate
Assert.AreEqual(dt, test.LastDate);
test.LastDate = dt = DateTime.Now;
Assert.AreEqual(dt, test.LastDate);
// Name
Assert.AreEqual("GenericClass, priority = 123", test.Name);
// add OnPrioritySet
EventHandler<EventArgs> handler = (s, a) => prioritySet = true;
test.OnPrioritySet += handler;
Assert.IsFalse(prioritySet);
// Priority
test.Priority = 321;
Assert.IsTrue(prioritySet);
Assert.AreEqual("GenericClass, priority = 321", test.Name);
// remove OnPrioritySet
prioritySet = false;
test.OnPrioritySet -= handler;
test.Priority = 111;
Assert.IsFalse(prioritySet);
}
private TcpSimplexServerHostEnvironment()
{
var protocol = new TcpCustomServerProtocolSetup(8085, new NullAuthenticationProvider(), true);
_host = new ZyanComponentHost("RecreateClientConnectionTestHost_TcpSimplex", protocol);
_host.RegisterComponent<ISampleServer, SampleServer>("SampleServer", ActivationType.SingleCall);
}
public void RefreshRegisteredComponentsTest()
{
using (var host = new ZyanComponentHost("RefreshTest", new NullServerProtocolSetup(123)))
using (var conn = new ZyanConnection("null://NullChannel:123/RefreshTest"))
{
// this component is registered after connection is established
var componentName = Guid.NewGuid().ToString();
host.RegisterComponent<ISampleServer, SampleServer>(componentName);
try
{
// proxy cannot be created because connection doesn't know about the component
var proxy1 = conn.CreateProxy<ISampleServer>(componentName);
Assert.Fail("Component is not yet known for ZyanConnection.");
}
catch (ApplicationException)
{
}
// refresh the list of registered components and create a proxy
conn.RefreshRegisteredComponents();
var proxy2 = conn.CreateProxy<ISampleServer>(componentName);
var echoString = "Hello there";
var result = proxy2.Echo(echoString);
Assert.AreEqual(echoString, result);
}
}
