public ThunkImplementation(ThunkImplementationFactory factory, object instance, Guid instanceId, RpcServer server)
{
this.factory = factory;
this.instance = instance;
this.server = server;
this.instanceId = instanceId;
}
static void Main(string[] args)
{
Log.Texte("", "---------------------------------------------------------------", ConsoleColor.DarkBlue);
Log.Texte("", " _______ _________ _______ _________ _______ _______ ", ConsoleColor.Cyan);
Log.Texte("", "( ____ )\\__ __/( ____ \\__ __/( ____ \\( )|\\ /|", ConsoleColor.Cyan);
Log.Texte("", "| ( )| ) ( | ( \\/ ) ( | ( \\/| () () || ) ( |", ConsoleColor.Cyan);
Log.Texte("", "| (____)| | | | (__ | | | (__ | || || || | | |", ConsoleColor.Cyan);
Log.Texte("", "| __) | | | __) | | | __) | |(_)| || | | |", ConsoleColor.Cyan);
Log.Texte("", "| (\\ ( | | | ( | | | ( | | | || | | |", ConsoleColor.Cyan);
Log.Texte("", "| ) \\ \\_____) (___| ) | | | (____/\\| ) ( || (___) |", ConsoleColor.Cyan);
Log.Texte("", "|/ \\__/\\_______/|/ )_( (_______/|/ \\|(_______)", ConsoleColor.Cyan);
Log.Texte("", "www.Strawberry-Pr0jcts.com", ConsoleColor.DarkCyan);
Log.Texte("", "---------------------------------------------------------------", ConsoleColor.DarkBlue);
// Loading all configs files
ConfigMgr.LoadConfigs();
Config = ConfigMgr.GetConfig<RealmConfig>();
Config.RealmInfo.GenerateName();
// Loading log level from file
if (!Log.InitLog(Config.LogLevel,"Realm"))
ConsoleMgr.WaitAndExit(2000);
CharactersMgr.CharactersDB = DBManager.Start(Config.CharactersDB.Total(), ConnectionType.DATABASE_MYSQL, "Characters");
if (CharactersMgr.CharactersDB == null)
ConsoleMgr.WaitAndExit(2000);
WorldMgr.WorldDB = DBManager.Start(Config.WorldDB.Total(), ConnectionType.DATABASE_MYSQL, "World");
if (WorldMgr.WorldDB == null)
ConsoleMgr.WaitAndExit(2000);
PacketProcessor.RegisterDefinitions();
// Starting Remote Client
Client = new RpcClient("Realm-" + Config.RealmInfo.RealmId, Config.RpcCharacter.RpcLocalIp, 1);
if (!Client.Start(Config.RpcCharacter.RpcServerIp, Config.RpcCharacter.RpcServerPort))
ConsoleMgr.WaitAndExit(2000);
Server = new RpcServer(Config.RpcMapServer.RpcClientStartingPort, 2);
if (!Server.Start(Config.RpcMapServer.RpcIp, Config.RpcMapServer.RpcPort))
ConsoleMgr.WaitAndExit(2000);
World = Client.GetLocalObject<WorldMgr>();
Accounts = Client.GetServerObject<AccountMgr>();
Characters = Client.GetLocalObject<CharactersMgr>();
// 1 : Loading WorldMgr
World.Load();
// 2 : Loading CharactersMgr
CharactersMgr.Client = Client;
CharactersMgr.MyRealm = Config.RealmInfo;
CharactersMgr.MyRealm.RpcInfo = Client.Info;
Characters.Load();
// 3 : Loading AccountsMgr
Accounts.RegisterRealm(Config.RealmInfo, Client.Info);
ConsoleMgr.Start();
}
public void unbind()
{
var loggerMock = AutoMockContainer.GetMock <ILogger <RpcServer> >();
var aclLoaderMock = AutoMockContainer.GetMock <INetworkAclLoader>();
RpcServer rpcServer = new RpcServer(GetRpcConfig(), loggerMock.Object, aclLoaderMock.Object);
// binding
rpcServer.BindOperation(null, "checkDifferent", new Func <int, string, bool>((a, b) =>
{
int.TryParse(b, out var bInt);
return(!bInt.Equals(a));
}));
rpcServer.BindController <Foo>();
// unbinding
rpcServer.UnbindController("Foo");
// calling
var resp = (bool)rpcServer.CallOperation(null, null, "checkDifferent", 2, "2");
Assert.IsFalse(resp);
rpcServer.CallOperation(null, "Foo", "Bar");
}
public void bindAndCall()
{
var loggerMock = AutoMockContainer.GetMock <ILogger <RpcServer> >();
var aclLoaderMock = AutoMockContainer.GetMock <INetworkAclLoader>();
RpcServer rpcServer = new RpcServer(GetRpcConfig(), loggerMock.Object, aclLoaderMock.Object);
// binding
rpcServer.BindOperation(null, "checkDifferent", new Func <int, string, bool>((a, b) =>
{
int.TryParse(b, out var bInt);
return(!bInt.Equals(a));
}));
rpcServer.BindOperation("math", "checkEquals", new Func <int, string, bool>((a, b) =>
{
int.TryParse(b, out var bInt);
return(bInt.Equals(a));
}));
rpcServer.BindController <MathController>();
rpcServer.BindController(typeof(Foo));
// inject
rpcServer.InjectSpecialParameter(context => new RandomObjectForTest()
{
RandomProp = "Hello"
});
// calling
var resp1 = (bool)rpcServer.CallOperation(null, null, "checkDifferent", 2, "2");
Assert.IsFalse(resp1);
var resp2 = (bool)rpcServer.CallOperation(null, "math", "checkEquals", new Dictionary <string, object>()
{
{ "a", 2 },
{ "b", "2" }
});
Assert.IsTrue(resp2);
var resp3 = (int)rpcServer.CallOperation(null, "math", "sum", 2, 3);
Assert.AreEqual(resp3, 5);
var resp4 = (int)rpcServer.CallOperation(null, "math", "sub", 3, 1);
Assert.AreEqual(resp4, 2);
var resp5 = (string)rpcServer.CallOperation(null, "Foo", "Bar");
Assert.AreEqual(resp5, "foo bar :)");
var resp6 = (string)rpcServer.CallOperation(null, "Foo", "PrettyMessage", "how are you?");
Assert.AreEqual(resp6, "Hello, how are you?");
}
static void Main(string[] args)
{
Int32 port = 13000;
IPAddress localAddr = IPAddress.Parse("127.0.0.1");
TcpListener tcpListener = new TcpListener(localAddr, port);
tcpListener.Start();
while (true)
{
Console.WriteLine("Waiting for a connection...");
TcpClient tcpClient = tcpListener.AcceptTcpClient();
Console.WriteLine("Connected!");
var controller = new RpcController();
var server = new RpcServer(controller);
server.RegisterService <ISampleService>(new SampleService());
var channel = new NetworkStreamRpcChannel(controller, tcpClient.GetStream());
channel.Start();
while (tcpClient.Connected)
{
System.Threading.Thread.Sleep(1000);
}
channel.CloseAndJoin();
Console.WriteLine("Connection closed.\n");
}
}
private void sync(RpcClient client, RpcServer server, int timeout)
{
RequestBody b1 = new RequestBody(1, RequestBody.DEFAULT_SYNC_STR);
object obj = null;
try
{
if (null == server)
{
obj = client.invokeSync(addr, b1, timeout);
}
else
{
Connection conn = client.getConnection(addr, timeout);
Assert.NotNull(serverConnectProcessor.Connection);
Connection serverConn = serverConnectProcessor.Connection;
obj = server.invokeSync(serverConn, b1, timeout);
}
Assert.Null("Should not reach here!");
}
catch (InvokeTimeoutException)
{
Assert.Null(obj);
}
catch (RemotingException e)
{
logger.LogError("Other RemotingException but RpcServerTimeoutException occurred in sync", e);
Assert.Null("Should not reach here!");
}
catch (ThreadInterruptedException e)
{
logger.LogError("ThreadInterruptedException in sync", e);
Assert.Null("Should not reach here!");
}
}
public void DemoClientProxyChain()
{
Guid iid1 = Guid.NewGuid();
Guid iid2 = Guid.NewGuid();
//forward reuests from iid1 to service iid2:
using (
RpcServer.CreateRpc(iid1,
new SearchService.ServerStub(
RpcClient.ConnectRpc(iid2, "ncalrpc", null, @"lrpctest").Authenticate(
RpcAuthenticationType.Self)))
.AddProtocol("ncalrpc", @"lrpctest")
.AddAuthNegotiate()
.StartListening())
//iid calls the implementation
using (RpcServer.CreateRpc(iid2, new SearchService.ServerStub(new AuthenticatedSearch()))
.AddProtocol("ncalrpc", @"lrpctest")
.AddAuthNegotiate()
.StartListening())
{
using (
SearchService client =
new SearchService(
RpcClient.ConnectRpc(iid1, "ncalrpc", null, @"lrpctest").Authenticate(
RpcAuthenticationType.Self)))
Assert.AreEqual(1,
client.Search(SearchRequest.CreateBuilder().AddCriteria(String.Empty).Build()).
ResultsCount);
}
}
static void Main(string[] args)
{
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(onError);
// Loading all configs files
ConfigMgr.LoadConfigs();
Config = ConfigMgr.GetConfig<AccountConfigs>();
// Loading log level from file
if (!Log.InitLog(Config.LogLevel, "AccountCacher"))
ConsoleMgr.WaitAndExit(2000);
AccountMgr.Database = DBManager.Start(Config.AccountDB.Total(), ConnectionType.DATABASE_MYSQL, "Accounts");
if (AccountMgr.Database == null)
ConsoleMgr.WaitAndExit(2000);
Server = new RpcServer(Config.RpcInfo.RpcClientStartingPort, 1);
if (!Server.Start(Config.RpcInfo.RpcIp, Config.RpcInfo.RpcPort))
ConsoleMgr.WaitAndExit(2000);
AcctMgr = Server.GetLocalObject<AccountMgr>();
AcctMgr.LoadRealms();
ConsoleMgr.Start();
}
static void Main(string[] args)
{
var config = new RpcServerConfiguration();
config.BindingEndPoint = new IPEndPoint(IPAddress.Loopback, 8089);
config.PreferIPv4 = true;
config.IsDebugMode = true;
//UseFullMethodName is a property that if it is false allows you in the CLIENT to call the methods only by it's name, check example further.
config.UseFullMethodName = false;
var defaultServiceTypeLocator = new DefaultServiceTypeLocator();
//Methods is the class I created with all the methods to be called.
defaultServiceTypeLocator.AddService(typeof(Methods));
config.ServiceTypeLocatorProvider = conf => defaultServiceTypeLocator;
using (var server = new RpcServer(config))
{
server.Start();
Console.ReadKey();
}
}
static void Main(string[] args)
{
Log.Texte("", "-------------------------------", ConsoleColor.DarkBlue);
Log.Texte("", " _____ _____ ", ConsoleColor.Cyan);
Log.Texte("", " /\\ | __ \\ / ____|", ConsoleColor.Cyan);
Log.Texte("", " / \\ | |__) | (___ ", ConsoleColor.Cyan);
Log.Texte("", " / /\\ \\ | ___/ \\___ \\ ", ConsoleColor.Cyan);
Log.Texte("", " / ____ \\| | ____) |", ConsoleColor.Cyan);
Log.Texte("", "/_/ \\_\\_| |_____/ APB-File", ConsoleColor.Cyan);
Log.Texte("", "http://AllPrivateServer.com", ConsoleColor.DarkCyan);
Log.Texte("", "-------------------------------", ConsoleColor.DarkBlue);
Assembly.Load("Common");
Log.Info("FileServer", "Starting...");
ConfigMgr.LoadConfigs();
Config = ConfigMgr.GetConfig <FileServerConfig>();
if (!Log.InitLog(Config.LogLevel, "FileServer"))
{
ConsoleMgr.WaitAndExit(2000);
}
Server = new RpcServer(Config.RpcInfo.RpcClientStartingPort, 0);
if (!Server.Start(Config.RpcInfo.RpcIp, Config.RpcInfo.RpcPort))
{
ConsoleMgr.WaitAndExit(2000);
}
Log.Success("FileServer", "Server loaded.");
ConsoleMgr.Start();
}
static void Main(string[] args)
{
Int32 port = 13000;
IPAddress localAddr = IPAddress.Parse("127.0.0.1");
TcpListener tcpListener = new TcpListener(localAddr, port);
tcpListener.Start();
while (true)
{
Console.WriteLine("Waiting for a connection...");
TcpClient tcpClient = tcpListener.AcceptTcpClient();
Console.WriteLine("Connected!");
var controller = new RpcController();
var server = new RpcServer(controller);
server.RegisterService<ISampleService>(new SampleService());
var channel = new NetworkStreamRpcChannel(controller, tcpClient.GetStream());
channel.Start();
while (tcpClient.Connected)
System.Threading.Thread.Sleep(1000);
channel.CloseAndJoin();
Console.WriteLine("Connection closed.\n");
}
}
private static void StartServer(Type interfaceType, Type implType, string pipeName)
{
//create the server
var controller = new RpcController();
var server = new RpcServer(controller);
//register the service with the server. We must specify the interface explicitly since we did not use attributes
server.GetType()
.GetMethod("RegisterService")
.MakeGenericMethod(interfaceType)
.Invoke(server, new[] { Activator.CreateInstance(implType) });
//build the connection using named pipes
try
{
pipeServerStreamIn = CreateNamedPipe(pipeName + "ctos", PipeDirection.In);
pipeServerStreamOut = CreateNamedPipe(pipeName + "stoc", PipeDirection.Out);
streamsCreated = true;
pipeServerStreamIn.WaitForConnection();
pipeServerStreamOut.WaitForConnection();
//create and start the channel which will receive requests
var channel = new StreamRpcChannel(controller, pipeServerStreamIn, pipeServerStreamOut, useSharedMemory: true);
channel.Start();
}
catch (IOException e)
{
//swallow and exit
Console.WriteLine("Something went wrong (pipes busy?), quitting: " + e);
throw;
}
}
public void UpdateNames(RpcServer server)
{
if (server.InterfaceId != InterfaceId ||
server.InterfaceVersion.Major != InterfaceMajorVersion ||
server.InterfaceVersion.Minor != InterfaceMinorVersion)
{
throw new ArgumentException("Name XML doesn't match the server identity");
}
if (Structures != null)
{
var structures = server.ComplexTypes.OfType <NdrBaseStructureTypeReference>().ToList();
foreach (var s in Structures)
{
if (structures.Count > s.Index)
{
s.UpdateNames(structures[s.Index]);
}
}
}
if (Procedures != null)
{
var procedures = server.Procedures.ToList();
foreach (var p in Procedures)
{
if (procedures.Count > p.Index)
{
p.UpdateNames(procedures[p.Index]);
}
}
}
}
static async Task Main(string[] args)
{
RpcServer server = new RpcServer()
{
RpcIPAddress = "127.0.0.6",
RpcPort = 8007
};
RpcServer.Procedures = new Procedures();
server.LogNotify += DisplayMessage;
server.ListenAsync();
RpcClient client = new RpcClient()
{
RpcServerIPAddress = "127.0.0.2",
RpcServerPort = 8006
};
client.LogNotify += DisplayMessage;
var r1 = await client.SendRequestAsync(@"{'jsonrpc': '2.0', 'method': 'Sum', 'params': [2,8], 'id': 4}");
var r2 = await client.SendRequestAsync(@"{'jsonrpc': '2.0', 'method': 'Print', 'id': }");
Console.WriteLine(r1);
Console.WriteLine(r2);
Console.ReadKey();
}
static async Task Main(string[] args)
{
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
IClusterClient client = new ClientBuilder().UseLocalhostClustering().Build();
await client.Connect();
var container = LoadConfiguration();
container.RegisterInstance(client.ServiceProvider.GetService <IGrainFactory>());
RpcServer server = new RpcServer(container.Build())
{
#if DEBUG
Debug = true
#endif
};
await server.Bind(20170).Run();
server.Container.Resolve <OrleansChunkViewSynchronizer>().StartSync(server);
await PrepareTest(client);
Console.ReadKey();
}
public void PingWithExtensionTest()
{
using (RpcServer server = RpcServer.CreateRpc(iid, new SearchService.ServerStub(new AuthenticatedSearch()))
.AddProtocol("ncacn_np", @"\pipe\p1"))
{
UnitTestRpcInterop.RegisterAllExtensions(server.ExtensionRegistry);
server.Ping += delegate(RpcPingRequest r)
{
if (r.HasExtension(UnitTestRpcInterop.CustomPingDataIn))
{
return(RpcPingResponse.CreateBuilder()
.SetExtension(UnitTestRpcInterop.CustomPingDataOut,
r.GetExtension(UnitTestRpcInterop.CustomPingDataIn))
.Build());
}
return(RpcPingResponse.DefaultInstance);
};
server.StartListening();
using (
RpcClient client =
RpcClient.ConnectRpc(iid, "ncacn_np", null, @"\pipe\p1").Authenticate(
RpcAuthenticationType.Anonymous))
{
UnitTestRpcInterop.RegisterAllExtensions(client.ExtensionRegistry);
RpcPingRequest r = RpcPingRequest.CreateBuilder()
.SetExtension(UnitTestRpcInterop.CustomPingDataIn, "ping-request-data")
.Build();
RpcPingResponse response = client.Ping(r);
Assert.IsTrue(response.HasExtension(UnitTestRpcInterop.CustomPingDataOut));
Assert.AreEqual("ping-request-data", response.GetExtension(UnitTestRpcInterop.CustomPingDataOut));
}
}
}
static void Main(string[] args)
{
Log.Texte("", "-------------------------------", ConsoleColor.DarkBlue);
Log.Texte("", ",---.o", ConsoleColor.Cyan);
Log.Texte("", "`---..,---.,---.,---.,---.", ConsoleColor.Cyan);
Log.Texte("", " |||---'| || |,---|", ConsoleColor.Cyan);
Log.Texte("", "`---'``---'` '` '`---^ Core", ConsoleColor.Cyan);
Log.Texte("", "http://siennacore.com", ConsoleColor.Blue);
Log.Texte("", "-------------------------------", ConsoleColor.DarkBlue);
// Loading log level from file
if (!Log.InitLog("Configs/Characters.log", "Characters"))
{
WaitAndExit();
}
// Loading all configs files
ConfigMgr.LoadConfigs();
Config = ConfigMgr.GetConfig <CharacterConfig>();
// Starting Remoting Server
if (!RpcServer.InitRpcServer("CharacterServer", Config.RpcKey, Config.RpcPort))
{
WaitAndExit();
}
// Creating Remote objects
new AccountMgr();
AccountMgr.AccountDB = DBManager.Start(Config.AccountsDB.Total(), ConnectionType.DATABASE_MYSQL, "Accounts");
if (AccountMgr.AccountDB == null)
{
WaitAndExit();
}
new CharacterMgr();
CharacterMgr.CharacterDB = DBManager.Start(Config.CharactersDB.Total(), ConnectionType.DATABASE_MYSQL, "Characters");
if (CharacterMgr.CharacterDB == null)
{
WaitAndExit();
}
new CacheMgr();
CacheMgr.CharacterDB = DBManager.Start(Config.CharactersDB.Total(), ConnectionType.DATABASE_MYSQL, "Characters");
if (CacheMgr.CharacterDB == null)
{
WaitAndExit();
}
CharacterMgr.Instance.LoadRealms();
CharacterMgr.Instance.LoadCreation_Names();
// Listening Client
if (!TCPManager.Listen <RiftServer>(Config.CharacterServerPort, "CharacterServer"))
{
WaitAndExit();
}
ConsoleMgr.Start();
}
/// <summary>
/// Creates a new NtCore object to run independently of all other NtCore objects
/// </summary>
public IndependentNtCore()
{
m_notifier = new Notifier();
m_rpcServer = new RpcServer();
m_storage = new Storage(m_notifier, m_rpcServer);
m_dispatcher = new Dispatcher(m_storage, m_notifier);
}
public void MultiPartMessageTest()
{
//Notice that both client and server must enable multi-part messages...
using (RpcServer.CreateRpc(iid, new SearchService.ServerStub(new AuthenticatedSearch()))
.AddAuthNegotiate()
.AddProtocol("ncacn_ip_tcp", "12345")
.EnableMultiPart()
.StartListening())
{
using (
SearchService client = new SearchService(RpcClient.ConnectRpc(iid, "ncacn_ip_tcp", "::1", "12345")
.Authenticate(RpcAuthenticationType.Self).
EnableMultiPart(1000000)))
{
// Non-LRPC channels have limitations on message sizes, we use multiple calls to forward large messages
// and store state on the server in the RpcSession associated with this client. This is all transparent
// to the caller, but this 7 meg message will produce several rpc-calls.
SearchRequest.Builder criteria = SearchRequest.CreateBuilder();
byte[] bytes = new byte[2500];
Random r = new Random();
for (int i = 0; i < 2500; i++)
{
r.NextBytes(bytes);
criteria.AddCriteria(Convert.ToBase64String(bytes));
}
SearchResponse results = client.Search(criteria.Build());
Assert.AreEqual(2500, results.ResultsCount);
}
}
}
protected override IDisposable StartServer(int responseSize)
{
_service = RpcServer.CreateRpc(Iid, CreateStub(responseSize));
PrepareService(_service, Iid);
_service.StartListening();
return(_service);
}
static void Main(String[] args)
{
XTrace.UseConsole();
var sc = new RpcServer()
{
Port = 1234,
Log = XTrace.Log,
EncoderLog = XTrace.Log,
NameSpace = "NewLife.Test",
};
var star = new StarClient("tcp://127.0.0.1:6666")
{
Code = "test",
Secret = "pass"
};
sc.Star = star;
sc.Start();
_Server = sc;
Thread.Sleep(-1);
}
public void TestServerCreate()
{
using (var server = new RpcServer(new TestActorService()))
{
}
Assert.Pass();
}
/// <summary>
/// Start game server.
/// <paramref name="period">Span between ticks.</paramref>
/// </summary>
public void Run(int period = DefaultPeriod, bool block = true)
{
RpcServer.Bind(20170).Run().ContinueWith(s => Logger.Info("Rpc server start ok."));
Logger.Info("SimCivil loop start running.");
var token = new CancellationTokenSource();
Task.Factory.StartNew(
() => GameLoop(period, token.Token),
token.Token,
TaskCreationOptions.LongRunning,
TaskScheduler.Default)
// ReSharper disable once MethodSupportsCancellation
.ContinueWith(t => Logger.Info("SimCivil stop loop."));
// ReSharper disable once LoopVariableIsNeverChangedInsideLoop
while (block)
{
switch (Console.ReadKey().Key)
{
case ConsoleKey.Escape:
token.Cancel();
Logger.Info("keyboard exit requested");
return;
}
}
}
// ~~~ server invoke test methods
// ~~~ private methods
private void oneway(RpcClient client, RpcServer server)
{
RequestBody b2 = new RequestBody(2, RequestBody.DEFAULT_ONEWAY_STR);
try
{
if (null == server)
{
client.oneway(addr, b2);
}
else
{
Connection conn = client.getConnection(addr, 1000);
Assert.NotNull(serverConnectProcessor.Connection);
Connection serverConn = serverConnectProcessor.Connection;
server.oneway(serverConn, b2);
}
Thread.Sleep(50);
}
catch (RemotingException e)
{
logger.LogError("Exception caught in oneway!", e);
Assert.Null("Exception caught!");
}
catch (ThreadInterruptedException e)
{
logger.LogError("ThreadInterruptedException in oneway", e);
Assert.Null("Should not reach here!");
}
}
public void DemoExampleConnection()
{
//obtain the interface id for rpc registration
Guid iid = Marshal.GenerateGuidForType(typeof(ISearchService));
//Create the server with a stub pointing to our implementation
using (RpcServer.CreateRpc(iid, new SearchService.ServerStub(new AuthenticatedSearch()))
//allow GSS_NEGOTIATE
.AddAuthNegotiate()
//LRPC named 'lrpctest'
.AddProtocol("ncalrpc", "lrpctest")
.AddProtocol("ncacn_ip_tcp", "12345")
.AddProtocol("ncacn_np", @"\pipe\p1")
//Begin responding
.StartListening())
{
// Demonstrate a typical client-implemented wrapper that can parse URIs, retry connections, etc.
using (var client = new SearchService(new ExampleRpcConnection(iid, "lrpc://localhost/lrpctest")))
Assert.AreEqual(1, client.Search(SearchRequest.CreateBuilder().AddCriteria("Test1").Build()).ResultsCount);
using (var client = new SearchService(new ExampleRpcConnection(iid, "rpc://self@localhost:12345")))
Assert.AreEqual(1, client.Search(SearchRequest.CreateBuilder().AddCriteria("Test2").Build()).ResultsCount);
using (var client = new SearchService(new ExampleRpcConnection(iid, "np://self@localhost/pipe/p1")))
Assert.AreEqual(1, client.Search(SearchRequest.CreateBuilder().AddCriteria("Test3").Build()).ResultsCount);
}
}
public void Init()
{
controller = new Mock <RpcController>();
squareCallMessage = new RpcMessage();
squareCallMessage.Id = 42;
squareCallMessage.CallMessage = new RpcMessage.Call();
squareCallMessage.CallMessage.Service = "ISampleService";
squareCallMessage.CallMessage.Method = "GetSquare";
squareCallMessage.CallMessage.ExpectsResult = true;
squareCallMessage.CallMessage.Parameters.Add(new RpcMessage.Parameter {
IntParam = 5
});
doStuffCallMessage = new RpcMessage();
doStuffCallMessage.Id = 43;
doStuffCallMessage.CallMessage = new RpcMessage.Call();
doStuffCallMessage.CallMessage.Service = "ISampleService";
doStuffCallMessage.CallMessage.Method = "DoStuff";
doStuffCallMessage.CallMessage.Parameters.Add(new RpcMessage.Parameter {
StringParam = "Hello"
});
testParamCallMessage = new RpcMessage();
testParamCallMessage.Id = 44;
testParamCallMessage.CallMessage = new RpcMessage.Call();
testParamCallMessage.CallMessage.Service = "ISampleService";
testParamCallMessage.CallMessage.ExpectsResult = true;
server = new RpcServer(controller.Object);
sampleService = new SampleService();
server.RegisterService(sampleService);
}
private static void TestSendNotify(int concurrency, Action <IPEndPoint, CountdownEvent, IProducerConsumerCollection <string> > test)
{
var endPoint = new IPEndPoint(IPAddress.Loopback, 57319);
var config = new RpcServerConfiguration();
config.BindingEndPoint = endPoint;
using (var arrivalLatch = new CountdownEvent(concurrency))
{
var arriveds = new ConcurrentQueue <string>();
config.DispatcherProvider =
s =>
new CallbackDispatcher(
s,
(id, args) =>
{
arriveds.Enqueue(args[0].ToString());
arrivalLatch.Signal();
return(args);
}
);
config.PreferIPv4 = true;
using (var server = new RpcServer(config))
using (var transportManager = new TcpServerTransportManager(server))
{
test(endPoint, arrivalLatch, arriveds);
}
}
}
static void Main(string[] args)
{
Log.Texte("", "-------------------------------", ConsoleColor.DarkBlue);
Log.Texte("", " _____ _____ ", ConsoleColor.Cyan);
Log.Texte("", " /\\ | __ \\ / ____|", ConsoleColor.Cyan);
Log.Texte("", " / \\ | |__) | (___ ", ConsoleColor.Cyan);
Log.Texte("", " / /\\ \\ | ___/ \\___ \\ ", ConsoleColor.Cyan);
Log.Texte("", " / ____ \\| | ____) |", ConsoleColor.Cyan);
Log.Texte("", "/_/ \\_\\_| |_____/ APB-File", ConsoleColor.Cyan);
Log.Texte("", "http://AllPrivateServer.com", ConsoleColor.DarkCyan);
Log.Texte("", "-------------------------------", ConsoleColor.DarkBlue);
Assembly.Load("Common");
Log.Info("FileServer", "Starting...");
ConfigMgr.LoadConfigs();
Config = ConfigMgr.GetConfig<FileServerConfig>();
if (!Log.InitLog(Config.LogLevel, "FileServer"))
ConsoleMgr.WaitAndExit(2000);
Server = new RpcServer(Config.RpcInfo.RpcClientStartingPort, 0);
if (!Server.Start(Config.RpcInfo.RpcIp, Config.RpcInfo.RpcPort))
ConsoleMgr.WaitAndExit(2000);
Log.Success("FileServer", "Server loaded.");
ConsoleMgr.Start();
}
private RpcClientBuilder(RpcServer server, RpcClientBuilderArguments args)
{
_server = server;
_type_descriptors = new Dictionary <NdrBaseTypeReference, RpcTypeDescriptor>();
_args = args;
_proc_names = new HashSet <string>();
}
static void Main(string[] args)
{
var options = new RpcServerOptions();
options.callback = Program.Callback;
var rpcServer = RpcServer.Create(options);
}
public void DemoRpcOverLrpc()
{
//obtain the interface id for rpc registration
Guid iid = Marshal.GenerateGuidForType(typeof(ISearchService));
//Create the server with a stub pointing to our implementation
using (RpcServer.CreateRpc(iid, new SearchService.ServerStub(new AuthenticatedSearch()))
//allow GSS_NEGOTIATE
.AddAuthNegotiate()
//LRPC named 'lrpctest'
.AddProtocol("ncalrpc", "lrpctest")
//Begin responding
.StartListening())
{
//Create the rpc client connection and give it to the new SearchService
using (
SearchService client =
new SearchService(
RpcClient.ConnectRpc(iid, "ncalrpc", null, "lrpctest").Authenticate(
RpcAuthenticationType.Self)))
{
//party on!
SearchResponse results =
client.Search(SearchRequest.CreateBuilder().AddCriteria("Test Criteria").Build());
Assert.AreEqual(1, results.ResultsCount);
Assert.AreEqual("Test Criteria", results.ResultsList[0].Name);
Assert.AreEqual("http://whatever.com", results.ResultsList[0].Url);
}
}
}
static void Main(string[] args)
{
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(onError);
Log.Texte("", "-------------------- Account Cacher -------------------", ConsoleColor.DarkRed);
// Loading all configs files
ConfigMgr.LoadConfigs();
Config = ConfigMgr.GetConfig <AccountConfigs>();
// Loading log level from file
if (!Log.InitLog(Config.LogLevel, "AccountCacher"))
{
ConsoleMgr.WaitAndExit(2000);
}
AccountMgr.Database = DBManager.Start(Config.AccountDB.Total(), Config.AccountDB.ConnectionType, "Accounts", Config.AccountDB.Database);
if (AccountMgr.Database == null)
{
ConsoleMgr.WaitAndExit(2000);
}
Server = new RpcServer(Config.RpcInfo.RpcClientStartingPort, 1);
if (!Server.Start(Config.RpcInfo.RpcIp, Config.RpcInfo.RpcPort))
{
ConsoleMgr.WaitAndExit(2000);
}
AcctMgr = Server.GetLocalObject <AccountMgr>();
AcctMgr.LoadRealms();
ConsoleMgr.Start();
}
internal ModifiedRpcServerResult(RpcServer server, RpcServer compare_server,
IEnumerable <NdrProcedureDefinition> added_procedure)
{
Server = server;
CompareServer = compare_server;
AddedProcedure = added_procedure.ToList().AsReadOnly();
}
private static void StartServer(Type interfaceType, Type implType, string pipeName)
{
//create the server
var controller = new RpcController();
var server = new RpcServer(controller);
//register the service with the server. We must specify the interface explicitly since we did not use attributes
server.GetType()
.GetMethod("RegisterService")
.MakeGenericMethod(interfaceType)
.Invoke(server, new[] {Activator.CreateInstance(implType)});
//build the connection using named pipes
try
{
pipeServerStreamIn = CreateNamedPipe(pipeName + "ctos", PipeDirection.In);
pipeServerStreamOut = CreateNamedPipe(pipeName + "stoc", PipeDirection.Out);
streamsCreated = true;
pipeServerStreamIn.WaitForConnection();
pipeServerStreamOut.WaitForConnection();
//create and start the channel which will receive requests
var channel = new StreamRpcChannel(controller, pipeServerStreamIn, pipeServerStreamOut, useSharedMemory: true);
channel.Start();
}
catch (IOException e)
{
//swallow and exit
Console.WriteLine("Something went wrong (pipes busy?), quitting: " + e);
throw;
}
}
static void Main(string[] args)
{
Log.Texte("", "-------------------------------", ConsoleColor.DarkBlue);
Log.Texte("", " _____ _____ ", ConsoleColor.Cyan);
Log.Texte("", " /\\ | __ \\ / ____|", ConsoleColor.Cyan);
Log.Texte("", " / \\ | |__) | (___ ", ConsoleColor.Cyan);
Log.Texte("", " / /\\ \\ | ___/ \\___ \\ ", ConsoleColor.Cyan);
Log.Texte("", " / ____ \\| | ____) |", ConsoleColor.Cyan);
Log.Texte("", "/_/ \\_\\_| |_____/ APB-Char", ConsoleColor.Cyan);
Log.Texte("", "http://AllPrivateServer.com", ConsoleColor.DarkCyan);
Log.Texte("", "-------------------------------", ConsoleColor.DarkBlue);
Assembly.Load("Common");
Log.Info("CharacterServer", "Starting...");
ConfigMgr.LoadConfigs();
Config = ConfigMgr.GetConfig<CharacterServerConfig>();
if (!Log.InitLog(Config.LogLevel, "CharacterServer"))
ConsoleMgr.WaitAndExit(2000);
CharacterMgr.Database = DBManager.Start(Config.CharacterDatabase.Total(), ConnectionType.DATABASE_MYSQL, "CharDB");
if(CharacterMgr.Database == null)
ConsoleMgr.WaitAndExit(2000);
Server = new RpcServer(Config.RpcInfo.RpcClientStartingPort, 0);
if (!Server.Start(Config.RpcInfo.RpcIp, Config.RpcInfo.RpcPort))
ConsoleMgr.WaitAndExit(2000);
Log.Success("CharacterServer", "Server loaded.");
ConsoleMgr.Start();
}
public virtual void testStopRepeatedly()
{
RpcServer rpcServer = new RpcServer(1111);
try
{
rpcServer.startup();
}
catch (Exception e)
{
Assert.Null("Should not reach here!");
Console.WriteLine(e.ToString());
Console.Write(e.StackTrace);
}
rpcServer.shutdown();
try
{
rpcServer.shutdown();
Assert.Null("Should not reach here!");
}
catch (Exception)
{
// expect IllegalStateException
}
}
public void Start()
{
if (mServer.IsRunning)
{
return;
}
var controller = new RpcController();
var server = new RpcServer(controller);
server.RegisterService(mJournal);
mServer.Start(Settings.Port, Settings.NumberOfConnections);
mServer.SocketProcessing = client =>
{
using (var channel = new TcpClientRpcChannel(controller, client, 5000)) //, "server"))
{
Console.WriteLine("Server get req RPC DATA ->>");
channel.Start();
channel.OnError = () => Console.WriteLine("Error: RPC channel not started: controller RPC,client socket, or port 5000");
while (channel.IsReady)
{
Thread.Sleep(50);
}
//Thread.Sleep(3000);
Console.WriteLine("<<-RPC DATA");
}
};
}
private static void TestCore( Action<ServerRequestContext, ServerTransport> test )
{
using ( var server = new RpcServer() )
using ( var manager = new NullServerTransportManager( server ) )
using ( var transport = new NullServerTransport( manager ) )
using ( var target = new ServerRequestContext() )
{
test( target, transport );
}
}
public void TestDispose()
{
using ( var server = new RpcServer() )
using ( var target = new Target( server ) )
{
target.Dispose();
Assert.That( target.GetIsDisposed(), Is.True );
Assert.That( target.DisposeCalled, Is.True );
}
}
public async Task StartAsync(string port)
{
if (_isDisposed)
throw new ObjectDisposedException(nameof(NetGameServer));
if (_rpcServer != null)
throw new InvalidOperationException();
var serializer = new DefaultJsonSerializer(typeof(NetGameServer).GetTypeInfo().Assembly, Serialization.JsonSerializationSettings);
_rpcServer = await RpcServer.StartAsync(port, this, serializer);
}
public void Init()
{
var controller = new RpcController();
client = new RpcClient(controller);
server = new RpcServer(controller);
server.RegisterService(new SampleService());
var channel = new LoopbackRpcChannel(controller);
channel.Start();
dynProxy = client.GetProxy("ISampleService");
}
public void TestDispatch_MethodExists_Success()
{
var svcFile = ".\\Services.svc";
File.WriteAllText(
svcFile,
String.Format( CultureInfo.InvariantCulture, "<% @ ServiceHost Service=\"{0}\" %>", typeof( TestService ).FullName )
);
try
{
var configuration = new RpcServerConfiguration();
configuration.ServiceTypeLocatorProvider = conf => new FileBasedServiceTypeLocator();
using ( var server = new RpcServer( configuration ) )
using ( var transportManager = new NullServerTransportManager( server ) )
using ( var transport = new NullServerTransport( transportManager ) )
using ( var requestContext = DispatchTestHelper.CreateRequestContext() )
using ( var argumentsBuffer = new MemoryStream() )
using ( var waitHandle = new ManualResetEventSlim() )
{
var message = Guid.NewGuid().ToString();
using ( var argumentsPacker = Packer.Create( argumentsBuffer, false ) )
{
argumentsPacker.PackArrayHeader( 1 );
argumentsPacker.Pack( message );
}
argumentsBuffer.Position = 0;
var target = new LocatorBasedDispatcher( server );
MessagePackObject response = MessagePackObject.Nil;
requestContext.MethodName = "Echo:TestService:1";
requestContext.MessageId = 1;
requestContext.SetTransport( transport );
requestContext.ArgumentsUnpacker = Unpacker.Create( argumentsBuffer );
transport.Sent +=
( sender, e ) =>
{
response = Unpacking.UnpackString( e.Context.GetReturnValueData() ).Value;
waitHandle.Set();
};
target.Dispatch( transport, requestContext );
Assert.That( waitHandle.Wait( TimeSpan.FromSeconds( 1 ) ) );
Assert.That( message == response, "{0} != {1}", message, response );
}
}
finally
{
File.Delete( svcFile );
}
}
/// <summary>
/// Initializes a new instance of the <see cref="LocatorBasedDispatcher"/> class.
/// </summary>
/// <param name="server">The server which will hold this instance.</param>
/// <exception cref="ArgumentNullException">
/// <paramref name="server"/> is <c>null</c>.
/// </exception>
public LocatorBasedDispatcher( RpcServer server )
: base( server )
{
this._locator = server.Configuration.ServiceTypeLocatorProvider( server.Configuration );
this._descriptionTable = server.Configuration.UseFullMethodName ? new VersionedOperationCatalog() : ( OperationCatalog )new FlatOperationCatalog();
foreach ( var service in this._locator.FindServices() )
{
foreach ( var operation in OperationDescription.FromServiceDescription( this.Runtime, service ) )
{
this._descriptionTable.Add( operation );
}
}
}
public async Task DisposeAsync()
{
if (!_isDisposed)
{
_isDisposed = true;
if (_rpcServer != null)
{
// Closing the server will disconnect all clients
// => OnDisconnected will correctly remove players from the game
await _rpcServer.DisposeAsync();
_rpcServer = null;
}
}
}
static void Main(string[] args)
{
Log.Texte("", "---------------------------------------------------------------", ConsoleColor.DarkBlue);
Log.Texte("", " _______ _________ _______ _________ _______ _______ ", ConsoleColor.Cyan);
Log.Texte("", "( ____ )\__ __/( ____ \\__ __/( ____ \( )|\ /|", ConsoleColor.Cyan);
Log.Texte("", "| ( )| ) ( | ( \/ ) ( | ( \/| () () || ) ( |", ConsoleColor.Cyan);
Log.Texte("", "| (____)| | | | (__ | | | (__ | || || || | | |", ConsoleColor.Cyan);
Log.Texte("", "| __) | | | __) | | | __) | |(_)| || | | |", ConsoleColor.Cyan);
Log.Texte("", "| (\ ( | | | ( | | | ( | | | || | | |", ConsoleColor.Cyan);
Log.Texte("", "| ) \ \_____) (___| ) | | | (____/\| ) ( || (___) |", ConsoleColor.Cyan);
Log.Texte("", "|/ \__/\_______/|/ )_( (_______/|/ \|(_______)", ConsoleColor.Cyan);
Log.Texte("", "www.Strawberry-Pr0jcts.com", ConsoleColor.DarkCyan);
Log.Texte("", "---------------------------------------------------------------", ConsoleColor.DarkBlue);
// Loading all configs files
ConfigMgr.LoadConfigs();
Config = ConfigMgr.GetConfig<CharacterConfig>();
// Loading log level from file
if (!Log.InitLog(Config.LogLevel,"Character"))
ConsoleMgr.WaitAndExit(2000);
AccountMgr.AccountDB = DBManager.Start(Config.AccountDB.Total(), ConnectionType.DATABASE_MYSQL, "Accounts");
if (AccountMgr.AccountDB == null)
ConsoleMgr.WaitAndExit(2000);
// Starting Remote Server
Server = new RpcServer(Config.RpcClientStartingPort, 1);
if (!Server.Start(Config.RpcIP, Config.RpcPort))
ConsoleMgr.WaitAndExit(2000);
// Starting Accounts Manager
AcctMgr = Server.GetLocalObject<AccountMgr>();
if(AcctMgr == null)
ConsoleMgr.WaitAndExit(2000);
AcctMgr.LoadRealms();
// Listening Client
if (!TCPManager.Listen<RiftServer>(Config.CharacterServerPort, "CharacterServer"))
ConsoleMgr.WaitAndExit(2000);
ConsoleMgr.Start();
}
private static void TestSendReceiveRequest( Action<IPEndPoint, UdpServerTransportManager> test )
{
var endPoint = new IPEndPoint( IPAddress.Loopback, 57319 );
var config = new RpcServerConfiguration();
config.BindingEndPoint = endPoint;
config.DispatcherProvider =
s =>
new CallbackDispatcher(
s,
( id, args ) => args
);
config.PreferIPv4 = true;
using ( var server = new RpcServer( config ) )
using ( var transportManager = new UdpServerTransportManager( server ) )
{
test( endPoint, transportManager );
}
}
static void Main(string[] args)
{
Log.Texte("", "-------------------------------", ConsoleColor.DarkBlue);
Log.Texte("", " _____ _____ ", ConsoleColor.Cyan);
Log.Texte("", " /\\ | __ \\ / ____|", ConsoleColor.Cyan);
Log.Texte("", " / \\ | |__) | (___ ", ConsoleColor.Cyan);
Log.Texte("", " / /\\ \\ | ___/ \\___ \\ ", ConsoleColor.Cyan);
Log.Texte("", " / ____ \\| | ____) |", ConsoleColor.Cyan);
Log.Texte("", "/_/ \\_\\_| |_____/ Rift", ConsoleColor.Cyan);
Log.Texte("", "http://AllPrivateServer.com", ConsoleColor.DarkCyan);
Log.Texte("", "-------------------------------", ConsoleColor.DarkBlue);
// Loading all configs files
ConfigMgr.LoadConfigs();
Config = ConfigMgr.GetConfig<CharacterConfig>();
// Loading log level from file
if (!Log.InitLog(Config.LogLevel,"Character"))
ConsoleMgr.WaitAndExit(2000);
AccountMgr.AccountDB = DBManager.Start(Config.AccountDB.Total(), ConnectionType.DATABASE_MYSQL, "Accounts");
if (AccountMgr.AccountDB == null)
ConsoleMgr.WaitAndExit(2000);
// Starting Remote Server
Server = new RpcServer(Config.RpcClientStartingPort, 1);
if (!Server.Start(Config.RpcIP, Config.RpcPort))
ConsoleMgr.WaitAndExit(2000);
// Starting Accounts Manager
AcctMgr = Server.GetLocalObject<AccountMgr>();
if(AcctMgr == null)
ConsoleMgr.WaitAndExit(2000);
AcctMgr.LoadRealms();
// Listening Client
if (!TCPManager.Listen<RiftServer>(Config.CharacterServerPort, "CharacterServer"))
ConsoleMgr.WaitAndExit(2000);
ConsoleMgr.Start();
}
public void TestRaiseServerError_RpcServerServerErrorEventOccurredWithSpeicifiedValues()
{
bool occurred = false;
using ( var server = new RpcServer() )
using ( var context = new ServerRequestContext() )
{
var exception = new InvalidOperationException();
server.ServerError +=
( sender, e ) =>
{
Assert.That( e.Exception, Is.EqualTo( exception ) );
occurred = true;
};
using ( var target = new Target( server ) )
{
target.RaiseServerError( exception );
Assert.That( occurred );
}
}
}
static async Task MainAsync()
{
var server = new RpcServer("127.0.0.1", 3000, conn =>
{
conn.On("Hello1", (string name) => string.Format("hello {0}", name));
conn.On("Hello2", async () =>
{
var name = await conn.Call<string>("GetName");
return string.Format("hello {0}", name);
});
conn.On("Add", (int num1, int num2) => num1 + num2);
conn.On("Test", (TestClass o) => o.Member.ToLower());
});
var client = new RpcClient("127.0.0.1", 3000);
client.On("GetName", () => "Rohan");
client.Connected += async () =>
{
try
{
Console.WriteLine("Hello1: {0}", await client.Call<string, string>("Hello1", "Brian"));
Console.WriteLine("Hello2: {0}", await client.Call<string>("Hello2"));
Console.WriteLine("Add: {0}", await client.Call<int, int, int>("Add", 10, 301));
Console.WriteLine("Test: {0}", await client.Call<TestClass, string>("Test", new TestClass { Member = "HELP" }));
}
catch (Exception e)
{
Console.WriteLine(e);
}
};
// give the client some time to connect
await Task.Delay(500);
}
public void TestRaiseClientError_RpcServerClientErrorEventOccurredWithSpeicifiedValues()
{
bool occurred = false;
using ( var server = new RpcServer() )
using ( var context = new ServerRequestContext() )
{
var error = RpcError.ArgumentError;
server.ClientError +=
( sender, e ) =>
{
Assert.That( e.MessageId, Is.EqualTo( context.MessageId ) );
Assert.That( e.RemoteEndPoint, Is.EqualTo( context.RemoteEndPoint ) );
Assert.That( e.RpcError.Error, Is.EqualTo( error ) );
Assert.That( e.SessionId, Is.EqualTo( context.SessionId ) );
occurred = true;
};
using ( var target = new Target( server ) )
{
target.RaiseClientError( context, new RpcErrorMessage( error, "Test" ) );
Assert.That( occurred );
}
}
}
static void Main(string[] args)
{
AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(onError);
Log.Texte("", "-------------------- Account Cacher -------------------", ConsoleColor.DarkRed);
Log.Texte("", " █ █░ ▄▄▄ ██▀███ ▓█████ ███▄ ▄███▓ █ ██ ", ConsoleColor.Red);
Log.Texte("", "▓█░ █ ░█░▒████▄ ▓██ ▒ ██▒▓█ ▀ ▓██▒▀█▀ ██▒ ██ ▓██▒", ConsoleColor.Red);
Log.Texte("", "▒█░ █ ░█ ▒██ ▀█▄ ▓██ ░▄█ ▒▒███ ▓██ ▓██░▓██ ▒██░", ConsoleColor.Red);
Log.Texte("", "░█░ █ ░█ ░██▄▄▄▄██ ▒██▀▀█▄ ▒▓█ ▄ ▒██ ▒██ ▓▓█ ░██░", ConsoleColor.Red);
Log.Texte("", "░░██▒██▓ ▓█ ▓██▒░██▓ ▒██▒░▒████▒▒██▒ ░██▒▒▒█████▓ ", ConsoleColor.Red);
Log.Texte("", "░ ▓░▒ ▒ ▒▒ ▓▒█░░ ▒▓ ░▒▓░░░ ▒░ ░░ ▒░ ░ ░░▒▓▒ ▒ ▒ ", ConsoleColor.Red);
Log.Texte("", " ▒ ░ ░ ▒ ▒▒ ░ ░▒ ░ ▒░ ░ ░ ░░ ░ ░░░▒░ ░ ░ ", ConsoleColor.Red);
Log.Texte("", " ░ ░ ░ ▒ ░░ ░ ░ ░ ░ ░░░ ░ ░ ", ConsoleColor.Red);
Log.Texte("", " ░ ░ ░ ░ ░ ░ ░ ░ ", ConsoleColor.Red);
Log.Texte("", "-------------------http://WarEmu.com-------------------", ConsoleColor.DarkRed);
// Loading all configs files
ConfigMgr.LoadConfigs();
Config = ConfigMgr.GetConfig<AccountConfigs>();
// Loading log level from file
if (!Log.InitLog(Config.LogLevel, "AccountCacher"))
ConsoleMgr.WaitAndExit(2000);
AccountMgr.Database = DBManager.Start(Config.AccountDB.Total(), ConnectionType.DATABASE_MYSQL, "Accounts");
if (AccountMgr.Database == null)
ConsoleMgr.WaitAndExit(2000);
Server = new RpcServer(Config.RpcInfo.RpcClientStartingPort, 1);
if (!Server.Start(Config.RpcInfo.RpcIp, Config.RpcInfo.RpcPort))
ConsoleMgr.WaitAndExit(2000);
AcctMgr = Server.GetLocalObject<AccountMgr>();
AcctMgr.LoadRealms();
ConsoleMgr.Start();
}
static void Main(string[] args)
{
serviceDefinition = ServiceInfoFactory.CreateServiceDefinition(new ServiceInfo { Port = Convert.ToInt32(ServiceConfig.Reader.Port) });
var store = new RegistryDatabaseFactory();
store.Create();
store.ApplySchema();
store.r.Connection.Dispose();
if (args.Length == 0 || args.Contains("-ampq"))
{
serviceRegistryServer = new RpcServer<ServiceInfo>(ConnectionConfig.GetFactoryDefault(), RegistrySettings.RegistryQueue, RegisterService);
serviceRegistryServer.StartInBackground();
statsConsumer = StartStatsConsumer();
Console.WriteLine("Registry AMPQ started");
}
if (args.Length == 0 || args.Contains("-web"))
{
webServer = WebApp.Start<Startup>(url: ServiceConfig.Reader.GetBaseAddress());
Console.WriteLine("Web server started");
}
Console.ReadLine();
if (statsConsumer != null)
{
statsConsumer.StopConsumer();
serviceRegistryServer.Stop();
}
if (webServer != null)
{
webServer.Dispose();
}
}
public void TestListen_NotIPv6OnlyOnWinNT6OrLator()
{
if ( Environment.OSVersion.Platform != PlatformID.Win32NT || Environment.OSVersion.Version.Major < 6 )
{
Assert.Ignore( "This test can be run on WinNT 6 or later." );
}
var config = new RpcServerConfiguration() { PreferIPv4 = false };
using ( var server = new RpcServer() )
using ( var target = new UdpServerTransportManager( server ) )
{
Socket listeningSocket = null;
target.GetListeningSocket( ref listeningSocket );
Assert.That( listeningSocket.GetSocketOption( SocketOptionLevel.IPv6, SocketOptionName.IPv6Only ), Is.EqualTo( 0 ) );
}
}
private static void TestSendNotify( int concurrency, Action<IPEndPoint, CountdownEvent, IProducerConsumerCollection<string>> test )
{
var endPoint = new IPEndPoint( IPAddress.Loopback, 57319 );
var config = new RpcServerConfiguration();
config.BindingEndPoint = endPoint;
using ( var arrivalLatch = new CountdownEvent( concurrency ) )
{
var arriveds = new ConcurrentQueue<string>();
config.DispatcherProvider =
s =>
new CallbackDispatcher(
s,
( id, args ) =>
{
arriveds.Enqueue( args[ 0 ].ToString() );
arrivalLatch.Signal();
return args;
}
);
config.PreferIPv4 = true;
using ( var server = new RpcServer( config ) )
using ( var transportManager = new UdpServerTransportManager( server ) )
{
test( endPoint, arrivalLatch, arriveds );
}
}
}
public void TestBeginShutdown()
{
using ( var server = new RpcServer() )
using ( var target = new Target( server ) )
{
target.BeginShutdown();
Assert.That( target.IsInShutdown, Is.True );
Assert.That( target.BeginShutdownCalled, Is.True );
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CallbackDispatcher"/> class.
/// </summary>
/// <param name="server">The server.</param>
/// <param name="dispatch">The callback with method name.</param>
public CallbackDispatcher( RpcServer server, Func<string, int?, MessagePackObject[], MessagePackObject> dispatch )
: base( server )
{
this._dispatch = dispatch;
}
/// <summary>
/// Initializes a new instance of the <see cref="ServerTransportManager"/> class.
/// </summary>
/// <param name="server">The server which will host this instance.</param>
/// <exception cref="ArgumentNullException">
/// <paramref name="server"/> is <c>null</c>.
/// </exception>
protected ServerTransportManager( RpcServer server )
{
if ( server == null )
{
throw new ArgumentNullException( "server" );
}
Contract.EndContractBlock();
this._requestContextPool = server.Configuration.RequestContextPoolProvider( () => new ServerRequestContext( server.Configuration ), server.Configuration.CreateRequestContextPoolConfiguration() );
this._responseContextPool = server.Configuration.ResponseContextPoolProvider( () => new ServerResponseContext( server.Configuration ), server.Configuration.CreateResponseContextPoolConfiguration() );
if ( this._requestContextPool == null )
{
throw new InvalidOperationException( "Configuration.RequestContextPoolProvider returns null." );
}
if ( this._responseContextPool == null )
{
throw new InvalidOperationException( "Configuration.ResponseContextPoolProvider returns null." );
}
this._server = server;
}
internal static HandleRef getCPtr(RpcServer obj)
{
return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
}
/// <summary>
/// Initializes a new instance of the <see cref="CallbackDispatcher"/> class.
/// </summary>
/// <param name="server">The server.</param>
/// <param name="callback">The callback without method name.</param>
public CallbackDispatcher( RpcServer server, Func<int?, MessagePackObject[], MessagePackObject> callback )
: base( server )
{
this._dispatch = ( method, id, args ) => callback( id, args );
}
public void TestDispatch_MethodNotExists_NoMethodError()
{
using ( var server = new RpcServer() )
using ( var transportManager = new NullServerTransportManager( server ) )
using ( var transport = new NullServerTransport( transportManager ) )
using ( var requestContext = DispatchTestHelper.CreateRequestContext() )
using ( var argumentsBuffer = new MemoryStream() )
using ( var waitHandle = new ManualResetEventSlim() )
{
var message = Guid.NewGuid().ToString();
using ( var argumentsPacker = Packer.Create( argumentsBuffer, false ) )
{
argumentsPacker.PackArrayHeader( 1 );
argumentsPacker.Pack( message );
}
argumentsBuffer.Position = 0;
var target = new LocatorBasedDispatcher( server );
MessagePackObject response = MessagePackObject.Nil;
requestContext.MethodName = "Echo:TestServices:1";
requestContext.MessageId = 1;
requestContext.SetTransport( transport );
requestContext.ArgumentsUnpacker = Unpacker.Create( argumentsBuffer );
transport.Sent +=
( sender, e ) =>
{
response = Unpacking.UnpackString( e.Context.GetErrorData() ).Value;
waitHandle.Set();
};
target.Dispatch( transport, requestContext );
Assert.That( waitHandle.Wait( TimeSpan.FromSeconds( 1 ) ) );
Assert.That( RpcError.NoMethodError.Identifier == response, "{0} != {1}", message, response );
}
}
