/// <summary>
/// Replaces custom codes in msg.
/// </summary>
/// <param name="conn"></param>
/// <param name="msg"></param>
private void HandleCustomCode(ChannelConnection conn, ref string msg)
{
// Wrap localization key
if (this.IsLocalizationKey(msg))
{
msg = this.WrapLocalizationKey(msg);
// Return, as there won't be any custom code.
return;
}
// {pcname} Character name
if (msg.IndexOf("{pcname}") != -1)
{
msg = msg.Replace("{pcname}", conn.SelectedCharacter.Name);
}
// {teamname} Character team name
if (msg.IndexOf("{teamname}") != -1)
{
msg = msg.Replace("{teamname}", conn.SelectedCharacter.TeamName);
}
// {fullname} Character name + team name
if (msg.IndexOf("{fullname}") != -1)
{
msg = msg.Replace("{fullname}", conn.SelectedCharacter.Name + " " + conn.SelectedCharacter.TeamName);
}
}
public async Task WebSocketsTransportStopsWhenConnectionClosedByTheServer(TransferMode transferMode)
{
using (StartLog(out var loggerFactory))
{
var connectionToTransport = Channel.CreateUnbounded <SendMessage>();
var transportToConnection = Channel.CreateUnbounded <byte[]>();
var channelConnection = new ChannelConnection <SendMessage, byte[]>(connectionToTransport, transportToConnection);
var webSocketsTransport = new WebSocketsTransport(httpOptions: null, loggerFactory: loggerFactory);
await webSocketsTransport.StartAsync(new Uri(_serverFixture.WebSocketsUrl + "/echo"), channelConnection, transferMode, connectionId : string.Empty, connection : Mock.Of <IConnection>());
var sendTcs = new TaskCompletionSource <object>();
connectionToTransport.Writer.TryWrite(new SendMessage(new byte[] { 0x42 }, sendTcs));
try
{
await sendTcs.Task;
}
catch (OperationCanceledException)
{
// Because the server and client are run in the same process there is a race where websocket.SendAsync
// can send a message but before returning be suspended allowing the server to run the EchoEndpoint and
// send a close frame which triggers a cancellation token on the client and cancels the websocket.SendAsync.
// Our solution to this is to just catch OperationCanceledException from the sent message if the race happens
// because we know the send went through, and its safe to check the response.
}
// The echo endpoint closes the connection immediately after sending response which should stop the transport
await webSocketsTransport.Running.OrTimeout();
Assert.True(transportToConnection.Reader.TryRead(out var buffer));
Assert.Equal(new byte[] { 0x42 }, buffer);
}
}
public async Task SSETransportStopsIfTheServerClosesTheStream()
{
var mockHttpHandler = new Mock <HttpMessageHandler>();
mockHttpHandler.Protected()
.Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>())
.Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) =>
{
await Task.Yield();
return(new HttpResponseMessage {
Content = new StringContent("data: 3:abc\r\n\r\n")
});
});
using (var httpClient = new HttpClient(mockHttpHandler.Object))
{
var sseTransport = new ServerSentEventsTransport(httpClient);
var connectionToTransport = Channel.CreateUnbounded <SendMessage>();
var transportToConnection = Channel.CreateUnbounded <byte[]>();
var channelConnection = new ChannelConnection <SendMessage, byte[]>(connectionToTransport, transportToConnection);
await sseTransport.StartAsync(
new Uri("http://fakeuri.org"), channelConnection, TransferMode.Text, connectionId : string.Empty).OrTimeout();
var message = await transportToConnection.Reader.ReadAsync().AsTask().OrTimeout();
Assert.Equal("3:abc", Encoding.ASCII.GetString(message));
await sseTransport.Running.OrTimeout();
}
}
public void EstablishContext()
{
using (var startEvent = new ManualResetEvent(false))
{
_srv = new TestService();
_channelAdaptor = new ChannelAdapter();
_hostChannel = WellknownAddresses.GetHostHost(_channelAdaptor);
_connection = _channelAdaptor.Connect(config => config.AddConsumerOf<ServiceStarted>().UsingConsumer(msg => startEvent.Set()));
ServiceConfigurator<TestService> c = new ServiceConfigurator<TestService>();
c.WhenStarted(s => s.Start());
c.WhenStopped(s => s.Stop());
c.WhenPaused(s => { _wasPaused = true; });
c.WhenContinued(s => { _wasContinued = true; });
c.HowToBuildService(name => _srv);
_serviceController = c.Create();
_serviceController.Start();
startEvent.WaitOne(5.Seconds());
_serviceController.State.ShouldEqual(ServiceState.Started);
}
}
void CreateCoordinatorChannel()
{
if (_channel != null)
{
return;
}
_channel = new ChannelAdapter();
_channelConnection = _channel.Connect(x =>
{
x.AddConsumerOf <ServiceEvent>()
.UsingConsumer(OnServiceEvent)
.HandleOnFiber(_fiber);
x.AddConsumerOf <ServiceFault>()
.UsingConsumer(OnServiceFault)
.HandleOnFiber(_fiber);
x.AddConsumerOf <ServiceStopped>()
.UsingConsumer(OnServiceStopped)
.HandleOnFiber(_fiber);
x.AddConsumerOf <CreateShelfService>()
.UsingConsumer(OnCreateShelfService)
.HandleOnFiber(_fiber);
x.AddConsumerOf <ServiceFolderChanged>()
.UsingConsumer(OnServiceFolderChanged)
.HandleOnFiber(_fiber);
x.AddConsumerOf <Request <ServiceStatus> >()
.UsingConsumer(Status)
.HandleOnFiber(_fiber);
});
}
public void A_request_is_sent_via_wcf()
{
_pipeUri = new Uri("net.pipe://localhost/pipe");
_response = new Future<Response<TestMessage>>();
_client = new ChannelAdapter();
_clientConnection = _client.Connect(x =>
{
x.SendToWcfChannel(_pipeUri, _pipeName)
.HandleOnCallingThread();
x.AddConsumerOf<Response<TestMessage>>()
.UsingConsumer(_response.Complete);
});
_server = new ChannelAdapter();
_serverConnection = _server.Connect(x =>
{
x.ReceiveFromWcfChannel(_pipeUri, _pipeName);
x.AddConsumerOf<Request<TestMessage>>()
.UsingConsumer(request => request.Respond(request.Body));
});
}
private CommandResult HandleSkillPoints(ChannelConnection conn, Character sender, Character target, string command, string[] args)
{
if (args.Length < 3)
{
return(CommandResult.InvalidArgument);
}
if (!int.TryParse(args[1], out var iJobId))
{
return(CommandResult.InvalidArgument);
}
if (!int.TryParse(args[2], out var modifier))
{
return(CommandResult.InvalidArgument);
}
var jobId = (JobId)iJobId;
if (!target.Jobs.ModifySkillPoints(jobId, modifier))
{
sender.ServerMessage("The job doesn't exist.");
return(CommandResult.Okay);
}
sender.ServerMessage("Modified {0}'s skill points by {1:+0;-0;0}.", jobId, modifier);
return(CommandResult.Okay);
}
/// <summary>
/// Creates a PollingFileSystemEventProducer
/// </summary>
/// <param name="directory">The directory to watch</param>
/// <param name="channel">The channel where events should be sent</param>
/// <param name="scheduler">Event scheduler</param>
/// <param name="fiber">Fiber to schedule on</param>
/// <param name="checkInterval">The maximal time between events or polls on a given file</param>
/// <param name="checkSubDirectory">Indicates if subdirectorys will be checked or ignored</param>
public PollingFileSystemEventProducer(string directory, UntypedChannel channel, [NotNull] Scheduler scheduler, Fiber fiber, TimeSpan checkInterval, bool checkSubDirectory)
{
if (scheduler == null)
throw new ArgumentNullException("scheduler");
_directory = directory;
_channel = channel;
_fiber = fiber;
_hashes = new Dictionary<string, Guid>();
_scheduler = scheduler;
_checkInterval = checkInterval;
_scheduledAction = scheduler.Schedule(3.Seconds(), _fiber, HashFileSystem);
var myChannel = new ChannelAdapter();
_connection = myChannel.Connect(connectionConfigurator =>
{
connectionConfigurator.AddConsumerOf<FileSystemChanged>().UsingConsumer(HandleFileSystemChangedAndCreated);
connectionConfigurator.AddConsumerOf<FileSystemCreated>().UsingConsumer(HandleFileSystemChangedAndCreated);
connectionConfigurator.AddConsumerOf<FileSystemRenamed>().UsingConsumer(HandleFileSystemRenamed);
connectionConfigurator.AddConsumerOf<FileSystemDeleted>().UsingConsumer(HandleFileSystemDeleted);
});
_fileSystemEventProducer = new FileSystemEventProducer(directory, myChannel, checkSubDirectory);
}
void Dispose(bool disposing)
{
if (_disposed)
{
return;
}
if (disposing)
{
if (_channelConnection != null)
{
_log.DebugFormat("[Topshelf] Closing coordinator channel");
_channelConnection.Dispose();
_channelConnection = null;
}
if (_updated != null && _updated.Implements <IDisposable>())
{
var disp = (IDisposable)_updated;
disp.Dispose();
}
_channel = null;
}
_disposed = true;
}
public void Starting_a_socket_server()
{
TraceLogger.Configure(LogLevel.Debug);
_startingEventReceived = new Future <ServerStarting>();
_runningEventReceived = new Future <ServerRunning>();
_input = new ChannelAdapter();
_connection = _input.Connect(x =>
{
x.AddConsumerOf <ServerStarting>()
.UsingConsumer(_startingEventReceived.Complete)
.HandleOnCallingThread();
x.AddConsumerOf <ServerRunning>()
.UsingConsumer(_runningEventReceived.Complete)
.HandleOnCallingThread();
});
ServerUri = new Uri("http://localhost:8008/Topshelf");
_server = new HttpServer(ServerUri, new ThreadPoolFiber(), _input, new[]
{
new VersionConnectionHandler(),
});
_server.Start();
}
private CommandResult HandleSpawn(ChannelConnection conn, Character character, Character target, string command, string[] args)
{
if (args.Length < 2)
{
return(CommandResult.InvalidArgument);
}
int id;
if (!int.TryParse(args[1], out id))
{
return(CommandResult.InvalidArgument);
}
var monsterData = ChannelServer.Instance.Data.MonsterDb.Find(id);
if (monsterData == null)
{
this.SystemMessage(character, "Monster not found.");
return(CommandResult.Okay);
}
var monster = new Monster(id, NpcType.Monster);
monster.Position = target.Position;
monster.Direction = target.Direction;
target.Map.AddMonster(monster);
return(CommandResult.Okay);
}
void OnServiceFolderRemoved(ServiceFolderRemoved message)
{
_log.InfoFormat("[Topshelf] Folder Removed: {0}", message.ServiceName);
if (_actorCache.Has(message.ServiceName))
{
var actor = _actorCache[message.ServiceName];
_actorCache.Remove(message.ServiceName);
_serviceCache.Remove(message.ServiceName);
ChannelConnection connection = null;
connection = _channel.Connect(x =>
{
x.AddConsumerOf <ServiceStopped>()
.Where(m => m.ServiceName == message.ServiceName)
.UsingConsumer(_ =>
{
actor.Send(new UnloadService(message.ServiceName));
});
x.AddConsumerOf <ServiceUnloaded>()
.Where(m => m.ServiceName == message.ServiceName)
.UsingConsumer(_ =>
{
// actor.Exit(); why timeout?
connection.Dispose();
});
});
actor.Send(new StopService(message.ServiceName));
}
}
public async Task SSETransportThrowsForInvalidTransferMode()
{
var mockHttpHandler = new Mock <HttpMessageHandler>();
mockHttpHandler.Protected()
.Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>())
.Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) =>
{
await Task.Yield();
return(new HttpResponseMessage {
Content = new StringContent(string.Empty)
});
});
using (var httpClient = new HttpClient(mockHttpHandler.Object))
{
var sseTransport = new ServerSentEventsTransport(httpClient);
var connectionToTransport = Channel.CreateUnbounded <SendMessage>();
var transportToConnection = Channel.CreateUnbounded <byte[]>();
var channelConnection = new ChannelConnection <SendMessage, byte[]>(connectionToTransport, transportToConnection);
var exception = await Assert.ThrowsAsync <ArgumentException>(() =>
sseTransport.StartAsync(new Uri("http://fakeuri.org"), null, TransferMode.Text | TransferMode.Binary, connectionId: string.Empty));
Assert.Contains("Invalid transfer mode.", exception.Message);
Assert.Equal("requestedTransferMode", exception.ParamName);
}
}
public async Task SSETransportStopsSendAndReceiveLoopsWhenTransportStopped()
{
var eventStreamCts = new CancellationTokenSource();
var mockHttpHandler = new Mock <HttpMessageHandler>();
mockHttpHandler.Protected()
.Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>())
.Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) =>
{
await Task.Yield();
var mockStream = new Mock <Stream>();
mockStream
.Setup(s => s.CopyToAsync(It.IsAny <Stream>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Returns <Stream, int, CancellationToken>(async(stream, bufferSize, t) =>
{
await Task.Yield();
var buffer = Encoding.ASCII.GetBytes("data: 3:abc\r\n\r\n");
while (!eventStreamCts.IsCancellationRequested)
{
await stream.WriteAsync(buffer, 0, buffer.Length);
}
});
mockStream.Setup(s => s.CanRead).Returns(true);
return(new HttpResponseMessage {
Content = new StreamContent(mockStream.Object)
});
});
Task transportActiveTask;
using (var httpClient = new HttpClient(mockHttpHandler.Object))
{
var sseTransport = new ServerSentEventsTransport(httpClient);
try
{
var connectionToTransport = Channel.CreateUnbounded <SendMessage>();
var transportToConnection = Channel.CreateUnbounded <byte[]>();
var channelConnection = new ChannelConnection <SendMessage, byte[]>(connectionToTransport, transportToConnection);
await sseTransport.StartAsync(
new Uri("http://fakeuri.org"), channelConnection, TransferMode.Text, connectionId : string.Empty).OrTimeout();
transportActiveTask = sseTransport.Running;
Assert.False(transportActiveTask.IsCompleted);
var message = await transportToConnection.Reader.ReadAsync().AsTask().OrTimeout();
Assert.Equal("3:abc", Encoding.ASCII.GetString(message));
}
finally
{
await sseTransport.StopAsync().OrTimeout();
}
await transportActiveTask.OrTimeout();
eventStreamCts.Cancel();
}
}
private async Task StartTransport(Uri connectUrl)
{
var applicationToTransport = Channel.CreateUnbounded<SendMessage>();
var transportToApplication = Channel.CreateUnbounded<byte[]>();
var applicationSide = ChannelConnection.Create(applicationToTransport, transportToApplication);
_transportChannel = ChannelConnection.Create(transportToApplication, applicationToTransport);
// Start the transport, giving it one end of the pipeline
try
{
await _transport.StartAsync(connectUrl, applicationSide, GetTransferMode(), this);
// actual transfer mode can differ from the one that was requested so set it on the feature
if (!_transport.Mode.HasValue)
{
// This can happen with custom transports so it should be an exception, not an assert.
throw new InvalidOperationException("Transport was expected to set the Mode property after StartAsync, but it has not been set.");
}
SetTransferMode(_transport.Mode.Value);
}
catch (Exception ex)
{
_logger.ErrorStartingTransport(_transport, ex);
throw;
}
}
public async Task LongPollingTransportSetsTransferMode(TransferMode transferMode)
{
var mockHttpHandler = new Mock <HttpMessageHandler>();
mockHttpHandler.Protected()
.Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>())
.Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) =>
{
await Task.Yield();
return(ResponseUtils.CreateResponse(HttpStatusCode.OK));
});
using (var httpClient = new HttpClient(mockHttpHandler.Object))
{
var longPollingTransport = new LongPollingTransport(httpClient);
try
{
var connectionToTransport = Channel.CreateUnbounded <SendMessage>();
var transportToConnection = Channel.CreateUnbounded <byte[]>();
var channelConnection = new ChannelConnection <SendMessage, byte[]>(connectionToTransport, transportToConnection);
Assert.Null(longPollingTransport.Mode);
await longPollingTransport.StartAsync(new Uri("http://fakeuri.org"), channelConnection, transferMode, connectionId : string.Empty, connection : new TestConnection());
Assert.Equal(transferMode, longPollingTransport.Mode);
}
finally
{
await longPollingTransport.StopAsync();
}
}
}
public async Task TransportClosesOnCloseTimeoutIfClientDoesNotSendCloseFrame()
{
var transportToApplication = Channel.CreateUnbounded <byte[]>();
var applicationToTransport = Channel.CreateUnbounded <byte[]>();
using (var transportSide = ChannelConnection.Create <byte[]>(applicationToTransport, transportToApplication))
using (var applicationSide = ChannelConnection.Create <byte[]>(transportToApplication, applicationToTransport))
using (var feature = new TestWebSocketConnectionFeature())
{
var options = new WebSocketOptions()
{
CloseTimeout = TimeSpan.FromSeconds(1)
};
var connectionContext = new DefaultConnectionContext(string.Empty, null, null);
var ws = new WebSocketsTransport(options, transportSide, connectionContext, loggerFactory: new LoggerFactory());
var serverSocket = await feature.AcceptAsync();
// Give the server socket to the transport and run it
var transport = ws.ProcessSocketAsync(serverSocket);
// End the app
applicationSide.Dispose();
await transport.OrTimeout(TimeSpan.FromSeconds(10));
// Now we're closed
Assert.Equal(WebSocketState.Aborted, serverSocket.State);
serverSocket.Dispose();
}
}
private CommandResult HandleRecallAll(ChannelConnection conn, Character sender, Character target, string command, string[] args)
{
if (args.Length > 1)
{
return(CommandResult.InvalidArgument);
}
// TODO: Once we have support for channels and map servers,
// add warp from other servers and restrict recall to
// channel's max player count.
// Check characters
var characters = ChannelServer.Instance.World.GetCharacters(a => a != target);
if (!characters.Any())
{
sender.ServerMessage("No players found.");
return(CommandResult.Okay);
}
// Recall each player to current location.
foreach (var character in characters)
{
var location = target.GetLocation();
character.Warp(location);
character.ServerMessage("You've been warped to {0}.", location);
}
sender.ServerMessage("You have called {0} characters to target location.", characters.Length);
return(CommandResult.Okay);
}
public async Task TransportFailsOnTimeoutWithErrorWhenApplicationFailsAndClientDoesNotSendCloseFrame()
{
var transportToApplication = Channel.CreateUnbounded <byte[]>();
var applicationToTransport = Channel.CreateUnbounded <byte[]>();
using (var transportSide = ChannelConnection.Create <byte[]>(applicationToTransport, transportToApplication))
using (var applicationSide = ChannelConnection.Create <byte[]>(transportToApplication, applicationToTransport))
using (var feature = new TestWebSocketConnectionFeature())
{
var options = new WebSocketOptions
{
CloseTimeout = TimeSpan.FromSeconds(1)
};
var connectionContext = new DefaultConnectionContext(string.Empty, null, null);
var ws = new WebSocketsTransport(options, transportSide, connectionContext, loggerFactory: new LoggerFactory());
var serverSocket = await feature.AcceptAsync();
// Give the server socket to the transport and run it
var transport = ws.ProcessSocketAsync(serverSocket);
// Run the client socket
var client = feature.Client.ExecuteAndCaptureFramesAsync();
// fail the client to server channel
applicationToTransport.Out.TryComplete(new Exception());
await Assert.ThrowsAsync <Exception>(() => transport).OrTimeout();
Assert.Equal(WebSocketState.Aborted, serverSocket.State);
}
}
private CommandResult HandleBuyAbilPoint(ChannelConnection conn, Character sender, Character target, string command, string[] args)
{
// Since this command is sent via UI interactions, we'll not
// use any automated command result messages, but we'll leave
// debug messages for now, in case of unexpected values.
if (args.Length < 0)
{
Log.Debug("HandleBuyAbilPoint: No amount given by user '{0}'.", conn.Account.Name);
return(CommandResult.Okay);
}
if (!int.TryParse(args[1], out var amount))
{
Log.Debug("HandleBuyAbilPoint: Invalid amount '{0}' by user '{1}'.", amount, conn.Account.Name);
return(CommandResult.Okay);
}
var cost = (amount * 1000);
var silver = sender.Inventory.CountItem(ItemId.Silver);
if (silver < cost)
{
Log.Debug("HandleBuyAbilPoint: User '{0}' didn't have enough money.", conn.Account.Name);
return(CommandResult.Okay);
}
sender.Inventory.Remove(ItemId.Silver, cost, InventoryItemRemoveMsg.Given);
sender.ModifyAbilityPoints(amount);
Send.ZC_ADDON_MSG(sender, "SUCCESS_BUY_ABILITY_POINTBLANK");
return(CommandResult.Okay);
}
public async Task ClientReceivesInternalServerErrorWhenTheApplicationFails()
{
using (StartLog(out var loggerFactory))
{
var transportToApplication = Channel.CreateUnbounded <byte[]>();
var applicationToTransport = Channel.CreateUnbounded <byte[]>();
using (var transportSide = ChannelConnection.Create <byte[]>(applicationToTransport, transportToApplication))
using (var applicationSide = ChannelConnection.Create <byte[]>(transportToApplication, applicationToTransport))
using (var feature = new TestWebSocketConnectionFeature())
{
var connectionContext = new DefaultConnectionContext(string.Empty, null, null);
var ws = new WebSocketsTransport(new WebSocketOptions(), transportSide, connectionContext, loggerFactory);
// Give the server socket to the transport and run it
var transport = ws.ProcessSocketAsync(await feature.AcceptAsync());
// Run the client socket
var client = feature.Client.ExecuteAndCaptureFramesAsync();
// Fail in the app
Assert.True(applicationSide.Writer.TryComplete(new InvalidOperationException("Catastrophic failure.")));
var clientSummary = await client.OrTimeout();
Assert.Equal(WebSocketCloseStatus.InternalServerError, clientSummary.CloseResult.CloseStatus);
// Close from the client
await feature.Client.CloseAsync(WebSocketCloseStatus.NormalClosure, "", CancellationToken.None);
var ex = await Assert.ThrowsAsync <InvalidOperationException>(() => transport.OrTimeout());
Assert.Equal("Catastrophic failure.", ex.Message);
}
}
}
private CommandResult HandleStatPoints(ChannelConnection conn, Character sender, Character target, string command, string[] args)
{
if (args.Length < 2)
{
return(CommandResult.InvalidArgument);
}
if (!int.TryParse(args[1], out var amount) || amount < 1)
{
return(CommandResult.InvalidArgument);
}
// Modification for stat points is a little tricky, because ToS
// has 3 stat points properties:
// - Stat points gained by leveling
// - Stat points gained in another way
// - Used stat points
// When increasing stats, "Used" is increased and the others are
// left alone. I'll make this adding-only for now, until I feel
// like untangling modifying them.
target.AddStatPoints(amount);
sender.ServerMessage("Added {0} stat points.", amount);
return(CommandResult.Okay);
}
private CommandResult HandleJob(ChannelConnection conn, Character character, Character target, string command, string[] args)
{
if (args.Length < 2)
{
return(CommandResult.InvalidArgument);
}
short jobId;
if (!short.TryParse(args[1], out jobId))
{
return(CommandResult.InvalidArgument);
}
if (!Enum.IsDefined(typeof(Job), jobId))
{
this.SystemMessage(character, "Unknown job.");
return(CommandResult.Okay);
}
target.Job = (Job)jobId;
Send.ZC_PC(target, PcUpdateType.Job, (short)jobId);
Send.ZC_UPDATED_PCAPPEARANCE(target);
return(CommandResult.Okay);
}
public TestClient(bool synchronousCallbacks = false)
{
var options = new ChannelOptimizations {
AllowSynchronousContinuations = synchronousCallbacks
};
var transportToApplication = Channel.CreateUnbounded <byte[]>(options);
var applicationToTransport = Channel.CreateUnbounded <byte[]>(options);
Application = ChannelConnection.Create <byte[]>(input: applicationToTransport, output: transportToApplication);
_transport = ChannelConnection.Create <byte[]>(input: transportToApplication, output: applicationToTransport);
Connection = new DefaultConnectionContext(Guid.NewGuid().ToString(), _transport, Application);
Connection.User = new ClaimsPrincipal(new ClaimsIdentity(new[] { new Claim(ClaimTypes.Name, Interlocked.Increment(ref _id).ToString()) }));
Connection.Metadata["ConnectedTask"] = new TaskCompletionSource <bool>();
var protocol = new JsonHubProtocol(new JsonSerializer());
_protocolReaderWriter = new HubProtocolReaderWriter(protocol, new PassThroughEncoder());
_cts = new CancellationTokenSource();
using (var memoryStream = new MemoryStream())
{
NegotiationProtocol.WriteMessage(new NegotiationMessage(protocol.Name), memoryStream);
Application.Out.TryWrite(memoryStream.ToArray());
}
}
private CommandResult HandleItemInfo(ChannelConnection conn, Character sender, Character target, string command, string[] args)
{
if (args.Length < 2)
{
return(CommandResult.InvalidArgument);
}
var search = command.Substring(command.IndexOf(" ")).Trim();
var items = ChannelServer.Instance.Data.ItemDb.FindAll(search);
if (items.Count == 0)
{
this.SystemMessage(sender, "No items found for '{0}'.", search);
return(CommandResult.Okay);
}
var eItems = items.OrderBy(a => a.Name.LevenshteinDistance(search)).ThenBy(a => a.Id).GetEnumerator();
var max = 20;
for (int i = 0; eItems.MoveNext() && i < max; ++i)
{
var item = eItems.Current;
this.SystemMessage(sender, "{0}: {1}, Category: {2}", item.Id, item.Name, item.Category);
}
this.SystemMessage(sender, "Results: {0} (Max. {1} shown)", items.Count, max);
return(CommandResult.Okay);
}
public async Task SSETransportSetsTransferMode(TransferMode transferMode)
{
var mockHttpHandler = new Mock <HttpMessageHandler>();
mockHttpHandler.Protected()
.Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>())
.Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) =>
{
await Task.Yield();
return(new HttpResponseMessage {
Content = new StringContent(string.Empty)
});
});
using (var httpClient = new HttpClient(mockHttpHandler.Object))
{
var sseTransport = new ServerSentEventsTransport(httpClient);
var connectionToTransport = Channel.CreateUnbounded <SendMessage>();
var transportToConnection = Channel.CreateUnbounded <byte[]>();
var channelConnection = new ChannelConnection <SendMessage, byte[]>(connectionToTransport, transportToConnection);
Assert.Null(sseTransport.Mode);
await sseTransport.StartAsync(new Uri("http://fakeuri.org"), channelConnection, transferMode, connectionId : string.Empty).OrTimeout();
Assert.Equal(TransferMode.Text, sseTransport.Mode);
await sseTransport.StopAsync().OrTimeout();
}
}
private CommandResult HandleName(ChannelConnection conn, Character character, Character target, string command, string[] args)
{
if (args.Length < 2)
{
return(CommandResult.InvalidArgument);
}
var newName = args[1];
if (newName == character.Name)
{
return(CommandResult.Okay);
}
// TODO: Can you rename any time, without cooldown?
// TODO: Keep a list of all account characters after all?
if (ChannelServer.Instance.Database.CharacterExists(conn.Account.Id, newName))
{
character.ServerMessage("Name already exists.");
return(CommandResult.Okay);
}
target.Name = newName;
Send.ZC_PC(target, PcUpdateType.Name, newName);
return(CommandResult.Okay);
}
public void A_request_is_sent_via_wcf()
{
_pipeUri = new Uri("net.pipe://localhost/pipe");
_response = new Future <Response <TestMessage> >();
_client = new ChannelAdapter();
_clientConnection = _client.Connect(x =>
{
x.SendToWcfChannel(_pipeUri, _pipeName)
.HandleOnCallingThread();
x.AddConsumerOf <Response <TestMessage> >()
.UsingConsumer(_response.Complete);
});
_server = new ChannelAdapter();
_serverConnection = _server.Connect(x =>
{
x.AddConsumerOf <Request <TestMessage> >()
.UsingConsumer(request => request.Respond(request.Body));
});
_host = new WcfChannelHost(new PoolFiber(), _server, _pipeUri, _pipeName);
}
private CommandResult HandleMonsterInfo(ChannelConnection conn, Character sender, Character target, string command, string[] args)
{
if (args.Length < 2)
{
return(CommandResult.InvalidArgument);
}
var search = command.Substring(command.IndexOf(" ")).Trim();
var monsters = ChannelServer.Instance.Data.MonsterDb.FindAll(search);
if (monsters.Count == 0)
{
sender.ServerMessage("No monsters found for '{0}'.", search);
return(CommandResult.Okay);
}
var entries = monsters.OrderBy(a => a.Name.LevenshteinDistance(search)).ThenBy(a => a.Id).GetEnumerator();
var max = 20;
for (var i = 0; entries.MoveNext() && i < max; ++i)
{
var current = entries.Current;
sender.ServerMessage("{0}: {1}", current.Id, current.Name);
}
sender.ServerMessage("Results: {0} (Max. {1} shown)", monsters.Count, max);
return(CommandResult.Okay);
}
public async Task LongPollingTransportStopsWhenPollReceives204()
{
var mockHttpHandler = new Mock <HttpMessageHandler>();
mockHttpHandler.Protected()
.Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>())
.Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) =>
{
await Task.Yield();
return(ResponseUtils.CreateResponse(HttpStatusCode.NoContent));
});
using (var httpClient = new HttpClient(mockHttpHandler.Object))
{
var longPollingTransport = new LongPollingTransport(httpClient);
try
{
var connectionToTransport = Channel.CreateUnbounded <SendMessage>();
var transportToConnection = Channel.CreateUnbounded <byte[]>();
var channelConnection = ChannelConnection.Create(connectionToTransport, transportToConnection);
await longPollingTransport.StartAsync(new Uri("http://fakeuri.org"), channelConnection, TransferMode.Binary, connectionId : string.Empty, connection : new TestConnection());
await longPollingTransport.Running.OrTimeout();
Assert.True(transportToConnection.Reader.Completion.IsCompleted);
}
finally
{
await longPollingTransport.StopAsync();
}
}
}
private CommandResult HandleRecall(ChannelConnection conn, Character sender, Character target, string command, string[] args)
{
if (args.Length < 2)
{
return(CommandResult.InvalidArgument);
}
// TODO: Once we have support for more than one map server,
// we have to search for characters across all of them.
var teamName = args[1];
var character = ChannelServer.Instance.World.GetCharacterByTeamName(teamName);
if (character == null)
{
sender.ServerMessage("Character not found.");
return(CommandResult.Okay);
}
var location = target.GetLocation();
character.Warp(location);
character.ServerMessage("You've been warped to {0}.", location);
return(CommandResult.Okay);
}
public async Task LongPollingTransportStopsWhenPollRequestFails()
{
var mockHttpHandler = new Mock <HttpMessageHandler>();
mockHttpHandler.Protected()
.Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>())
.Returns <HttpRequestMessage, CancellationToken>(async(request, cancellationToken) =>
{
await Task.Yield();
return(ResponseUtils.CreateResponse(HttpStatusCode.InternalServerError));
});
using (var httpClient = new HttpClient(mockHttpHandler.Object))
{
var longPollingTransport = new LongPollingTransport(httpClient);
try
{
var connectionToTransport = Channel.CreateUnbounded <SendMessage>();
var transportToConnection = Channel.CreateUnbounded <byte[]>();
var channelConnection = new ChannelConnection <SendMessage, byte[]>(connectionToTransport, transportToConnection);
await longPollingTransport.StartAsync(new Uri("http://fakeuri.org"), channelConnection, TransferMode.Binary, connectionId : string.Empty);
var exception =
await Assert.ThrowsAsync <HttpRequestException>(async() => await transportToConnection.Reader.Completion.OrTimeout());
Assert.Contains(" 500 ", exception.Message);
}
finally
{
await longPollingTransport.StopAsync();
}
}
}
private CommandResult HandleReqUpdateEquip(ChannelConnection conn, Character sender, Character target, string command, string[] args)
{
// Command is sent when the inventory is opened, purpose unknown,
// officials don't seem to send anything back.
return(CommandResult.Okay);
}
public void Run()
{
Stopwatch timer = Stopwatch.StartNew();
const int channelCount = 10000;
const int seedCount = 500;
var channels = new UntypedChannel[channelCount];
var connections = new ChannelConnection[channelCount];
var complete = new Future<int>();
var latch = new CountdownLatch(channelCount*seedCount, complete.Complete);
for (int i = 0; i < channelCount; i++)
{
int channelNumber = i;
channels[i] = new ChannelAdapter();
connections[i] = channels[i].Connect(x =>
{
x.AddConsumerOf<AMessage>()
.UsingConsumer(message =>
{
if (channelNumber < channels.Length - 1)
channels[channelNumber + 1].Send(message);
latch.CountDown();
});
});
}
var body = new AMessage();
for (int i = 0; i < seedCount; i++)
{
channels[i].Send(body);
for (int j = 0; j < i; j++)
latch.CountDown();
}
bool completed = complete.WaitUntilCompleted(2.Minutes());
timer.Stop();
connections.Each(x => x.Dispose());
if (!completed)
{
Console.WriteLine("Process did not complete");
return;
}
Console.WriteLine("Processed {0} messages in with {1} channels in {2}ms", seedCount, channelCount,
timer.ElapsedMilliseconds);
Console.WriteLine("That's {0} messages per second!", ((long)seedCount*channelCount*1000)/timer.ElapsedMilliseconds);
}
public void Close_connection()
{
if (_connection != null)
{
_connection.Dispose();
_connection = null;
}
}
public HostHost(UntypedChannel inputChannel, Uri address, string endpoint)
{
_input = inputChannel;
_inputConnection = _input.Connect(x =>
{
x.ReceiveFromWcfChannel(address, endpoint)
.HandleOnCallingThread();
});
}
public void After()
{
_inputConnection.Dispose();
_inputConnection = null;
_input = null;
_outputConnection.Dispose();
_outputConnection = null;
_output = null;
}
public void After()
{
_clientConnection.Dispose();
_clientConnection = null;
_client = null;
_serverConnection.Dispose();
_serverConnection = null;
_server = null;
}
public void A_message_is_sent_to_an_instance()
{
_auctionId = CombGuid.Generate();
_input = new ChannelAdapter();
_connection = _input.Connect(x =>
{
x.AddConsumerOf<Bid>()
.UsingInstance().Of<Auction>()
.ObtainedBy(m => new Auction(m.AuctionId))
.OnChannel(auction => auction.BidChannel);
});
}
public void Start()
{
// file system watcher will fail if directory isn't there, ensure it is
if (!Directory.Exists(_baseDirectory))
Directory.CreateDirectory(_baseDirectory);
_scheduler = new TimerScheduler(new PoolFiber());
_channel = new ChannelAdapter();
_producer = new PollingFileSystemEventProducer(_baseDirectory, _channel, _scheduler, new PoolFiber(),
10.Minutes());
_connection = _channel.Connect(x =>
{
x.AddConsumerOf<FileSystemEvent>()
.UsingConsumer(msg => ScheduleFolderChangeNotification(GetChangedDirectory(msg.Path)))
.HandleOnFiber(_fiber);
});
}
public void Start()
{
_eventConnection = _eventChannel.Connect(x =>
{
x.AddConsumerOf<ReceiveCompleted>()
.UsingConsumer(Handle)
.HandleOnCallingThread();
x.AddConsumerOf<ConsumeCompleted>()
.UsingConsumer(Handle)
.HandleOnCallingThread();
});
_enabled = true;
if (_log.IsDebugEnabled)
_log.DebugFormat("Starting Consumer Pool for {0}", _bus.Endpoint.Address.Uri);
QueueReceiver();
}
public void Configuring_event_listeners_for_nhibernate()
{
using (ISession session = SessionFactory.OpenSession())
using (ITransaction transaction = session.BeginTransaction())
{
session.CreateQuery("Delete TestInstance").ExecuteUpdate();
session.CreateQuery("Delete TestInstanceAudit").ExecuteUpdate();
transaction.Commit();
}
_channel = new ChannelAdapter();
_connection = _channel.Connect(x =>
{
x.AddConsumersFor<TestInstanceAudit>()
.BindUsing<TestInstanceAuditBinding, AuditKey>()
.HandleOnCallingThread()
.CreateNewInstanceBy(id => new TestInstanceAudit(id))
.PersistUsingNHibernate()
.UseSessionProvider(() => SessionFactory.OpenSession());
});
ResetSessionFactory();
ExtraConfiguration = cfg => { cfg.AddAuditEventListeners(_channel); };
using (ISession session = SessionFactory.OpenSession())
using (ITransaction transaction = session.BeginTransaction())
{
session.CreateQuery("Delete TestInstance").ExecuteUpdate();
var instance = new TestInstance(27, 123.45m);
session.Save(instance);
instance = new TestInstance(37, 123.45m);
session.Save(instance);
instance = new TestInstance(47, 123.45m);
session.Save(instance);
transaction.Commit();
}
}
public void Starting_a_socket_server()
{
_startingEventReceived = new Future<ServerStarting>();
_runningEventReceived = new Future<ServerRunning>();
_input = new ChannelAdapter();
_connection = _input.Connect(x =>
{
x.AddConsumerOf<ServerStarting>()
.UsingConsumer(_startingEventReceived.Complete)
.HandleOnCallingThread();
x.AddConsumerOf<ServerRunning>()
.UsingConsumer(_runningEventReceived.Complete)
.HandleOnCallingThread();
});
_uri = new Uri("tcp://0.0.0.0:8008");
_server = new SocketServer(_uri, _input);
_server.Start();
}
public void Connecting_two_services_through_a_wcf_proxy_and_host()
{
_pipeUri = new Uri("net.pipe://localhost/pipe");
_consumer = new Future<TestMessage>();
_input = new ChannelAdapter();
_inputConnection = _input.Connect(x =>
{
x.ReceiveFromWcfChannel(_pipeUri, _pipeName);
x.AddConsumerOf<TestMessage>()
.UsingConsumer(_consumer.Complete);
});
_output = new ChannelAdapter();
_outputConnection = _output.Connect(x =>
{
x.SendToWcfChannel(_pipeUri, _pipeName)
.HandleOnCallingThread();
});
}
public void Starting_a_socket_server()
{
_startingEventReceived = new Future<ServerStarting>();
_runningEventReceived = new Future<ServerRunning>();
_input = new ChannelAdapter();
_connection = _input.Connect(x =>
{
x.AddConsumerOf<ServerStarting>()
.UsingConsumer(_startingEventReceived.Complete)
.HandleOnCallingThread();
x.AddConsumerOf<ServerRunning>()
.UsingConsumer(_runningEventReceived.Complete)
.HandleOnCallingThread();
});
ServerUri = new Uri("http://localhost:8008/Topshelf");
_server = new HttpServer(ServerUri, _input, new[]
{
new VersionConnectionHandler(),
});
_server.Start();
}
void CreateChannelNetwork()
{
_connectionChannel = new ChannelAdapter<ConnectionContext>();
_connectionChannelConnection = _connectionChannel.Connect(x =>
{
var channelProvider = new HttpConnectionChannelProvider(_connectionHandlers);
var threadPoolChannel = new ThreadPoolChannel<ConnectionContext>(channelProvider, _concurrentConnectionLimit);
x.AddChannel(threadPoolChannel);
});
}
void Dispose(bool disposing)
{
if (_disposed) return;
if (disposing)
{
if (_eventConnection != null)
{
_eventConnection.Dispose();
_eventConnection = null;
}
}
_disposed = true;
}
public void Stop()
{
if (_producer != null)
{
_producer.Dispose();
_producer = null;
}
_pendingNotifications.Each(x => x.Value.Cancel());
if (_scheduler != null)
{
_scheduler.Stop(30.Seconds());
_scheduler = null;
}
if (_connection != null)
{
_connection.Dispose();
_connection = null;
}
_channel = null;
}
public void Start()
{
// file system watcher will fail if directory isn't there, ensure it is
if (!Directory.Exists(_baseDirectory))
Directory.CreateDirectory(_baseDirectory);
_scheduler = new TimerScheduler(new PoolFiber());
_channel = new ChannelAdapter();
_producer = new PollingFileSystemEventProducer(_baseDirectory, _channel, _scheduler, new PoolFiber(),
2.Minutes());
_connection = _channel.Connect(config =>
{
config
.AddConsumerOf<FileSystemEvent>()
.BufferFor(3.Seconds())
.UseScheduler(_scheduler)
.Distinct(fsEvent => GetChangedDirectory(fsEvent.Path))
.UsingConsumer(fsEvents =>
{
fsEvents.Keys.Distinct().Each(key =>
{
if (key == _baseDirectory)
return;
_serviceChannel.Send(new ServiceFolderChanged(key));
});
})
.HandleOnFiber(_fiber);
});
}
public void Stop()
{
if (_producer != null)
{
_producer.Dispose();
_producer = null;
}
if (_scheduler != null)
{
_scheduler.Stop(30.Seconds());
_scheduler = null;
}
if (_connection != null)
{
_connection.Dispose();
_connection = null;
}
_channel = null;
}
public void After()
{
_connection.Dispose();
_connection = null;
_input = null;
}
public void Setup()
{
_channel = new ChannelAdapter();
_channelConnection = _channel.Connect(x =>
{
x.AddConsumerOf<SomeEvent>()
.UsingConsumer(m => { })
.HandleOnCallingThread();
x.AddConsumerOf<AnyEvent>()
.UsingConsumer(m => { });
x.AddConsumerOf<AnyEvent>()
.UsingConsumer(m => { });
x.AddConsumerOf<SomeEvent>()
.UsingInstance()
.Of<MyConsumer>()
.ObtainedBy(m => new MyConsumer())
.OnChannel(c => c.Input);
x.AddConsumerOf<AnyEvent>()
.BufferFor(5.Minutes())
.Distinct(m => m.Key)
.UsingConsumer(ms => { })
.HandleOnFiber();
x.AddConsumerOf<AnyEvent>()
.Where(m => m.Key > 100)
.UsingConsumer(m => { })
.HandleOnThread();
x.AddConsumerOf<SomeEvent>()
.BufferFor(5.Minutes())
.Last()
.UsingConsumer(m => { })
.HandleOnFiber();
});
}
