public Task <ChannelReader <MatchListItemDto> > GetCurrentMatchesStream()
{
var streamProvider = _clusterClient.GetStreamProvider("SMSProvider");
var matchStream = streamProvider.GetStream <MatchListItemDto>(Guid.Empty, "MatchList");
return(matchStream.AsChannelReader());
}
public async Task <IReceivedAckSentToQuestionOwnerResult> Work(ReceivedAckSentToQuestionOwnerCmd cmd, QuestionWriteContext state, QuestionDependencies dependencies)
{
var asyncHelloGrain = this.clusterClient.GetGrain <IAsyncHello>(0);
await asyncHelloGrain.StartAsync();
var stream = clusterClient.GetStreamProvider("SMSProvider").GetStream <string>(Guid.Empty, "chat");
await stream.OnNextAsync("*****@*****.**");
return(new AckSentToQuestionOwnerResult(1, 2));
}
public async Task JoinChannel(string channelName)
{
var client = _orleansClient.GetGrain <IClient>(Context.GetAccessToken());
var streamId = await client.JoinChannel(channelName);
var streamSubscription = await _orleansClient.GetStreamProvider(Constants.ChatRoomStreamProvider)
.GetStream <Message>(streamId, Constants.CharRoomStreamNameSpace)
.SubscribeAsync(new StreamObserver(Clients, Context.ConnectionId, channelName));
await _orleansClient.GetGrain <IStreamSubscriptionMap>(Constants.ClusterId)
.AddSubscription(Context.GetAccessToken(), streamSubscription.HandleId);
}
public async Task <Guid> CreateSubscription(HubCallerContext context, Guid subscriptionId, Action <SubscriptionEventArgs> action)
{
if (subscriptionId != Guid.Empty)
{
var subs = await orleansClient.GetStreamProvider(Constants.StreamProvider)
.GetStream <TodoNotification>(Constants.TodoKey, nameof(ITodo)).GetAllSubscriptionHandles();
var existingSub = subs.FirstOrDefault(s => s.HandleId == subscriptionId);
if (existingSub != null)
{
// remove from group
await hubContext.Groups.RemoveFromGroupAsync(context.ConnectionId, SubGroup);
}
}
// only create one subscription -
if (!isSubsriptionEnabled)
{
this.subscription = await orleansClient.GetStreamProvider(Constants.StreamProvider)
.GetStream <TodoNotification>(Constants.TodoKey, nameof(ITodo))
.SubscribeAsync(new TodoItemObserver(loggerFactory, (notification) => {
logger.LogInformation("Received Notification");
var record = string.Empty;
switch (notification.NotificationType)
{
case NotificationType.Add:
logger.LogInformation($"TodoHub Added: {notification.Item.Title}");
record = $"Added: {notification.Item.Title}";
break;
case NotificationType.Remove:
logger.LogInformation($"TodoHub Removed: {notification.Item.Title}");
record = $"Removed: {notification.Item.Title}";
break;
case NotificationType.Clear:
logger.LogInformation("TodoHub Cleared all Todos");
record = "Cleared all Todos";
break;
}
action(new SubscriptionEventArgs(hubContext, record, notification.Item));
logger.LogInformation("Notification Sent");
return(Task.CompletedTask);
}));
isSubsriptionEnabled = true;
}
// add user to group
await hubContext.Groups.AddToGroupAsync(context.ConnectionId, SubGroup);
return(this.subscription.HandleId);
}
private static async Task LeaveChannel(IClusterClient client)
{
if (!EnsureChannelMembership())
{
return;
}
PrettyConsole.Line($"Leaving channel {_joinedChannel}");
var room = client.GetGrain <IChannel>(_joinedChannel);
var roomId = await room.GetId();
var stream = client.GetStreamProvider(Constants.ChatRoomStreamProvider).GetStream <ChatMsg>(roomId, Constants.CharRoomStreamNameSpace);
//unsubscribe from the channel/stream since client left, so that client won't
//receive future messages from this channel/stream
var subscriptionHandles = await stream.GetAllSubscriptionHandles();
foreach (var handle in subscriptionHandles)
{
await handle.UnsubscribeAsync();
}
await room.Leave(_userName);
_joinedChannel = null;
}
private static async Task JoinChannel(IClusterClient client, string channelName)
{
if (_joinedChannel == channelName)
{
PrettyConsole.Line($"You already joined channel {channelName}. Double joining a channel, which is implemented as a stream, would result in double subscription to the same stream, " +
$"which would result in receiving duplicated messages. For more information, please refer to Orleans streaming documentation.");
return;
}
PrettyConsole.Line($"Joining to channel {channelName}");
var room = client.GetGrain <IChannel>(channelName);
var roomId = await room.GetId();
var stream = client.GetStreamProvider(Constants.ChatRoomStreamProvider).GetStream <ChatMsg>(roomId, Constants.CharRoomStreamNameSpace);
var logger = client.ServiceProvider.GetService <ILoggerFactory>().CreateLogger($"{channelName} channel");
//subscribe to the stream to receiver farther messages sent to the chatroom
await stream.SubscribeAsync(new StreamObserver(logger));
await room.Join(_userName);
_joinedChannel = channelName;
}
private async Task ConnectToClusterAsync()
{
await EnsureOrleansClusterConnection();
OrleansLog.Subscribing(_logger, _id);
var provider = _clusterClient.GetStreamProvider(Constants.STREAM_PROVIDER);
_clientMessageStream = provider.GetStream <ClientInvocationMessage>(_id, Constants.CLIENT_MESSAGE_STREAM_NAMESPACE);
await _clientMessageStream.SubscribeAsync(async (message, token) => await OnReceivedClientMessageAsync(message));
_allMessageStream = provider.GetStream <AllInvocationMessage>(_hubTypeId, Constants.HUB_MESSAGE_STREAM_NAMESPACE);
await _allMessageStream.SubscribeAsync(async (message, token) => await OnReceivedAllMessageAsync(message));
try
{
await _clusterClient.GetHubLifetimeManagerGrain(_id, _hubTypeId).OnInitializeAsync(_options.TimeoutInterval ?? TimeSpan.FromSeconds(30));
// Tick heartbeat
heartbeatDisposable = Observable.Interval(TimeSpan.FromSeconds(1))
.Subscribe(async value =>
{
await _clusterClient.GetHubLifetimeManagerGrain(_id, _hubTypeId).OnHeartbeatAsync();
});
}
catch (Exception e)
{
OrleansLog.InternalMessageFailed(_logger, e);
}
}
public async Task <List <TexeraTuple> > DoClientWork(IClusterClient client, Guid workflowID, string plan)
{
RequestContext.Set("targetSilo", Constants.ClientIPAddress);
var deployGrain = client.GetGrain <IDeployGrain>(workflowID);
var controllerGrain = await deployGrain.Init(workflowID, plan, false);
var streamProvider = client.GetStreamProvider("SMSProvider");
var so = new StreamObserver();
var stream = streamProvider.GetStream <Immutable <PayloadMessage> >(controllerGrain.GetPrimaryKey(), "OutputStream");
var handle = await stream.SubscribeAsync(so);
so.SetNumEndFlags(await controllerGrain.GetNumberOfOutputGrains());
instance.IDToWorkflowEntry[workflowID] = controllerGrain;
await so.Start();
await controllerGrain.Start();
while (!so.isFinished)
{
}
await handle.UnsubscribeAsync();
await controllerGrain.Deactivate();
instance.IDToWorkflowEntry.Remove(workflowID);
return(so.resultsToRet);
}
public override async Task OnConnectAsync(WebSocket webSocket, RouteValueDictionary values)
{
var room = Convert.ToInt64(values["room"]);
var streamProvider = client.GetStreamProvider(Constants.StreamProviders.ChatRooms);
var chat = client.GetGrain <IChatRoom>(room);
var streamId = await chat.JoinAsync();
roomId = room;
stream = streamProvider.GetStream <ChatMessage>(streamId, Constants.Streams.Namespaces.Chats);
var handlers = await stream.GetAllSubscriptionHandles();
if (null == handlers || 0 == handlers.Count)
{
subscription = await stream.SubscribeAsync(OnStreamMessage);
}
else
{
foreach (var handler in handlers)
{
subscription = await handler.ResumeAsync(OnStreamMessage);
}
}
registry[room].Add(webSocket);
}
private async Task ActiveSessionAsync(HubCallerContext context)
{
var guid = context.UserIdentifier.ToGuid();
var stream = _clusterClient.GetStreamProvider("SMS").GetStream <IPacket <string> >(guid, nameof(IHubSession));
var player = _clusterClient.GetGrain <IPlayer>(context.UserIdentifier);
var userSession = _clusterClient.GetGrain <IHubSession>(guid);
var observer = new HubObserver(userSession, Clients.Client(context.ConnectionId));
var handle = await stream.SubscribeAsync(observer);
var feature = context.Features.Get <IHttpContextFeature>();
var sessionContext = new HubSessionContext
{
Id = guid,
ChannelId = context.ConnectionId,
StreamHandle = handle,
RemoteAddress = new IPEndPoint(feature.HttpContext.Connection.RemoteIpAddress, feature.HttpContext.Connection.RemotePort)
};
await userSession.Online(sessionContext, player);
if (!Users.TryAdd(context.UserIdentifier, observer))
{
observer.Close();
}
var hearbeat = Context.Features.Get <IConnectionHeartbeatFeature>();
hearbeat.OnHeartbeat(ctx => Task.Factory.StartNew(OnClientPing, ctx), Context);
}
internal void IncomingMessage(NList message)
{
int message_id = message.Get <int>(0);
NList dispatch_msg = message.GetRange(1, message.Count - 1);
if (message_id == SystemMsg.CLIENT.ACCESS_TOKEN && !Inited)
{
string access_token = dispatch_msg.Get <string>(0);
int realm = dispatch_msg.Get <int>(1);
IAccessToken token = _ClusterClient.GetGrain <IAccessToken>(access_token);
Guid user_id = token.GetUserId().Result;
_User = _ClusterClient.GetGrain <IUser>(user_id);
long role = _User.GetRole(realm).Result;
RoleAgent = _ClusterClient.GetGrain <IRoleAgent>(role);
RoleAgent.BindSession(user_id, Protocol.ToString());
_AgentObserver = new AgentObserver(this);
var stream = _ClusterClient.GetStreamProvider(StreamProviders.AgentProvider).GetStream <NList>(user_id, Protocol.ToString());
_SubscriptionHandle = stream.SubscribeAsync(_AgentObserver).Result;
Inited = true;
OutcomingMessage(NList.New().Add(SystemMsg.SERVER.ACCESS_TOKEN).Add(true));
}
else if (Inited)
{
if (RoleAgent != null)
{
RoleAgent.OnResponse(message_id, dispatch_msg);
}
}
}
static async Task Main(string[] args)
{
var builder = new ClientBuilder()
.UseLocalhostClustering()
.Configure <ClusterOptions>(options =>
{
options.ClusterId = "dev";
options.ServiceId = "EthereumBlockChainHarvester";
})
.AddSimpleMessageStreamProvider("SMSProvider")
.ConfigureLogging(logging => logging.AddConsole());
IClusterClient client = builder.Build();
await Task.Delay(100);
Console.WriteLine("Connecting...");
await client.Connect();
var streamProvider = client.GetStreamProvider("SMSProvider");
var stream = streamProvider.GetStream <byte[]>(Guid.Parse("db260371-c425-41df-b729-f530c2367bb5"), "hello");
await stream.SubscribeAsync <byte[]>(async (data, token) => { Console.WriteLine(BitConverter.ToString(data)); });
var extractor = client.GetGrain <IBlockChainExtractor>(0);
await extractor.DoWork();
Console.WriteLine("Job's done");
await extractor.DoWork();
Console.WriteLine("Job's done");
await extractor.DoWork();
Console.WriteLine("Job's done");
await extractor.DoWork();
Console.WriteLine("Job's done");
var server = new Server()
{
Services =
{
Scynet.Component.BindService(new ComponentFacade())
},
Ports = { new ServerPort("0.0.0.0", 0, ServerCredentials.Insecure) }
};
Console.WriteLine("Starting facade...");
server.Start();
Console.WriteLine("Yay, everything worked!");
Console.WriteLine("\nPress Enter to terminate...\n");
Console.ReadLine();
await server.ShutdownAsync();
}
public HubProxy(IClusterClient clusterClient)
: base(clusterClient,
() => clusterClient.GetStreamProvider(OrleansSignalRConstants.StreamProviderName),
typeof(THub).GetHubName(),
typeof(THub).GetAllStreamKey())
{
}
public Task RunPrimes()
{
var grain = _client.GetGrain <IPrime>(0);
var key = grain.GetGrainIdentity().PrimaryKey;
var stream = _client.GetStreamProvider(InterfaceConst.SMSProvider)
.GetStream <int>(key, InterfaceConst.PSPrime);
for (int mil = 0; mil < 1; mil++)
{
var tasks = new List <Task>();
for (int dez = mil == 0 ? 100 : 0; dez < 1000; dez += 10)
{
var item = mil * 1000 + dez;
tasks.Add(stream.OnNextAsync(item + 1));
tasks.Add(stream.OnNextAsync(item + 3));
tasks.Add(stream.OnNextAsync(item + 7));
tasks.Add(stream.OnNextAsync(item + 9));
}
Task.WaitAll(tasks.ToArray());
}
return(Task.CompletedTask);
}
public async Task StartAsync(CancellationToken cancellationToken)
{
var user = this.client.GetGrain <IUserGrain>(1);
await user.SayHello($"Message");
var streamProvider = client.GetStreamProvider("KafkaStreamProvider");
var stream = streamProvider.GetStream <string>(Guid.Empty, "testTopic");
Console.WriteLine("Ready to send messages ?");
Console.ReadLine();
//var user = this.client.GetGrain<IUserGrain>(1);
// example of calling grains from the initialized client
for (var i = 0; i <= 200; i++)
{
//var result = await user.SayHello($"Message{i}");
//await stream.OnNextAsync(new SimpleResultSpecification
//{
// Value = i
//});
//
await stream.OnNextAsync($"Message: {i}");
//Console.WriteLine(result);
}
Console.ReadLine();
}
public async Task InitAsync()
{
//configure the client with proper cluster options, logging and clustering
ClientBuilder builder = new ClientBuilder();
builder
.UseLocalhostClustering()
.Configure <ClusterOptions>(options =>
{
options.ClusterId = "dev";
options.ServiceId = "HelloWorldApp";
})
.ConfigureLogging(logging => { /*logging.AddConsole();*/ });
// add message stream provider
ClientStreamExtensions.AddSimpleMessageStreamProvider(builder, "TestStream");
client = builder.Build();
await client.Connect();
// subscribe stream
Guid guid = Guid.NewGuid();
// call grains from the initialized client
var friend = client.GetGrain <ITestStream>(0);
var response = await friend.RegisterStream(guid);
Console.WriteLine("\n\n{0}\n\n", response);
var streamProvider = client.GetStreamProvider("TestStream");
var stream = streamProvider.GetStream <string>(guid, "Test");
await stream.SubscribeAsync(testObserver);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="clusterClient">The Orleans <see cref="IClusterClient"/>.</param>
/// <param name="logger">The
/// <see>
/// <cref>ILogger{ICommandDispatcher{TCommand, TSuccess, TFailure}}</cref>.
/// </see>
/// </param>
/// <param name="streamId">The stream identifier.</param>
/// <param name="streamProviderName">The stream namespace.</param>
/// <param name="streamFactory">The stream factory.</param>
internal CommandDispatcher(IClusterClient clusterClient, IStreamFactory streamFactory,
ILogger <CommandDispatcher <TCommand, TSuccess, TFailure> > logger, Guid streamId, string streamProviderName)
{
_logger = logger;
_streamProvider = clusterClient.GetStreamProvider(streamProviderName);
_streamId = streamId;
_streamFactory = streamFactory;
}
private async Task InitializeAsync()
{
await EnsureOrleansClusterConnection();
OrleansLog.Subscribing(_logger, _id);
try
{
_clientMessageStream = _clusterClient.GetStreamProvider(SignalRConstants.STREAM_PROVIDER).GetStream <SendClientInvocationMessage>(_id, InternalSignalRConstants.SEND_CLIENT_MESSAGE_STREAM_NAMESPACE);
_clientMessageHandle = await _clientMessageStream.SubscribeAsync(async (message, token) => await OnReceivedAsync(message));
_allMessageHandle = await HubProxy.AllMessageStream.SubscribeAsync(async (message, token) => await OnReceivedAsync(message));
}
catch (Exception e)
{
OrleansLog.InternalMessageFailed(_logger, e);
}
}
/// <summary>
/// 获取遵循FIFO原则的SimpleMessageStream提供者
/// </summary>
/// <param name="clusterClient">Orleans服务集群客户端</param>
/// <returns>流提供者</returns>
public static IStreamProvider GetSimpleMessageStreamProvider(this IClusterClient clusterClient)
{
if (clusterClient == null)
{
throw new ArgumentNullException(nameof(clusterClient));
}
return(clusterClient.GetStreamProvider(ContextKeys.SimpleMessageStreamProviderName));
}
private async Task <Task> SetUpSource()
{
await SetUpTopology();
var streamId = await source.Join(userName);
var stream = client.GetStreamProvider(Constants.FaultTolerantStreamProvider)
.GetStream <StreamMessage>(streamId, Constants.FaultTolerantStreamNameSpace);
//subscribe to the stream to receiver furthur messages sent to the chatroom
Mock <ILogger> mockLogger = new Mock <ILogger>();
statefulStreamObserver = new StatefulStreamObserver(mockLogger.Object);
await stream.SubscribeAsync(statefulStreamObserver);
members = await source.GetMembers();
return(Task.CompletedTask);
}
public async override Task <ISendQuestionOwnerAcknowledgementResult> Work(SendQuestionOwnerAcknowledgementCmd cmd, QuestionsWriteContext state, QuestionsDependencies dependencies)
{
var asyncHelloGrain = this.clusterClient.GetGrain <IAsyncHello>($"User{cmd.QuestionOwnerId}");
await asyncHelloGrain.StartAsync();
var stream = clusterClient.GetStreamProvider("SMSProvider").GetStream <string>(Guid.Empty, "email");
await stream.OnNextAsync($"user{cmd.QuestionOwnerId}@email.com");
return(new AcknowledgementSent(1, 2));
}
public async override Task <ISendReplyAuthorAcknowledgementResult> Work(SendReplyAuthorAckCmd cmd, QuestionWriteContext state, QuestionDependencies dependencies)
{
var asyncHelloGrain = this.clusterClient.GetGrain <IAsyncHello>("user1");
await asyncHelloGrain.StartAsync();
var stream = clusterClient.GetStreamProvider("SMSProvider").GetStream <string>(Guid.Empty, "chat");
await stream.OnNextAsync("*****@*****.**");
return(new AcknowledgementSent(1, 2));
}
public async Task <IActionResult> CreateQuestion()
{
//presupunem ca am creat intrebarea
//await _interpreter.Interpret(expr, QuestionWriteContext);
var stream = _clusterClient.GetStreamProvider("SMSProvider")
.GetStream <CreateQuestionResult.ICreateQuestionResult>(Guid.Empty, "1/questions");
await stream.OnNextAsync(new CreateQuestionResult.QuestionPosted(new Guid("1"), "titlu", "corp", "Tag"));
return(Ok());
}
private static async Task Client2(IClusterClient client)
{
// STEP 1: create IDs for all grains and streams
var tagSourceGrain = Guid.NewGuid();
var photoSourceGrain = Guid.NewGuid();
var gpsSourceGrain = Guid.NewGuid();
var sinkGrain = Guid.NewGuid();
var tag = Guid.NewGuid();
var photo = Guid.NewGuid();
var gps = Guid.NewGuid();
var tagStream = Guid.NewGuid();
var photoStream = Guid.NewGuid();
var gpsStream = Guid.NewGuid();
var jobManager = client.GetGrain <IJobManagerGrain>(0, "JobManager");
// STEP 2: register all subscribes and publishes, which only add the information to JobManager
await jobManager.RegisterSubscribe(tagSourceGrain, tag);
await jobManager.RegisterSubscribe(photoSourceGrain, photo);
await jobManager.RegisterSubscribe(gpsSourceGrain, gps);
await jobManager.RegisterSubscribe(sinkGrain, tagStream);
await jobManager.RegisterSubscribe(sinkGrain, photoStream);
await jobManager.RegisterSubscribe(sinkGrain, gpsStream);
await jobManager.RegisterPublish(tagSourceGrain, tagStream);
await jobManager.RegisterPublish(photoSourceGrain, photoStream);
await jobManager.RegisterPublish(gpsSourceGrain, gpsStream);
// STEP 3: register the operators, which will activate the grain
await jobManager.RegisterISourceGrain(tagSourceGrain, "SourceGrain", "", "0");
await jobManager.RegisterISourceGrain(photoSourceGrain, "SourceGrain", "", "0");
await jobManager.RegisterISourceGrain(gpsSourceGrain, "SourceGrain", "", "0");
await jobManager.RegisterISinkGrain(sinkGrain, "SinkGrain", "", "0");
// STEP 4: activate the streams
var streamProvider = client.GetStreamProvider("SMSProvider");
var Tag = streamProvider.GetStream <string>(tag, null);
var Photo = streamProvider.GetStream <string>(photo, null);
var GPS = streamProvider.GetStream <string>(gps, null);
// STEP 5: let DataDriver feeds data to streams
await DataDriver.Run(Photo, Tag, GPS, 1600, 0);
}
public void Dispose()
{
if (!_initialized)
{
return;
}
OrleansHubLifetimeManagerLog.Unsubscribe(_logger, _clientStreamId);
var streamProvider = _clusterClient.GetStreamProvider(OrleansSignalRConstants.StreamProviderName);
var tasks = _connectionsById.Keys.Select(id => streamProvider
.GetStream <EventArgs>(OrleansSignalRConstants.DisconnectionStreamId, id)
.OnNextAsync(EventArgs.Empty));
Task.WaitAll(tasks.ToArray());
Task.WaitAll(
_allMessageHandle.UnsubscribeAsync(),
_clientMessageHandle.UnsubscribeAsync());
}
private static async Task DoClientWork(IClusterClient client)
{
var friend = client.GetGrain <IHello>(0);
var response = await friend.SayHello("Good morning, HelloGrain!");
Console.WriteLine($"\n\n{response}\n\n");
var guid = Guid.Empty;
var streamProvider = client.GetStreamProvider("SMSProvider");
var stream = streamProvider.GetStream <string>(guid, "CHAT");
await stream.OnNextAsync("Hello event");
}
public async Task RunHellos()
{
var grain = _client.GetGrain <IHello>(0);
var key = grain.GetGrainIdentity().PrimaryKey;
var stream = _client.GetStreamProvider(InterfaceConst.SMSProvider)
.GetStream <string>(key, InterfaceConst.PSHello);
for (int i = 1; i < 10; i++)
{
await stream.OnNextAsync($"Good morning, {i}!");
}
}
private TryAsync <ConfirmationAcknowledgement> SendEmail(ConfirmationLetter letter)
=> async() =>
{
var emailSender = _client.GetGrain <IEmailQuestionSender>(Guid.NewGuid());
await emailSender.SendConfirmationEmailAsync(letter.Letter);
var guid = Guid.Empty;
var streamProvider = _client.GetStreamProvider("SMSProvider");
var stream = streamProvider.GetStream <string>(guid, "LETTER");
await stream.OnNextAsync("Hello event");
return(new ConfirmationAcknowledgement(Guid.NewGuid().ToString()));
};
public async Task <IActionResult> CreateQuestion()
{
var stream = _client.GetStreamProvider("SMSProvider").GetStream <Post>(Guid.Empty, "questions");
var post = new Post
{
PostId = 2,
PostText = "My question2"
};
await stream.OnNextAsync(post);
return(Ok());
}
private static async Task DoClientWork(IClusterClient client)
{
// Create a player
string playerId = "nullorvoid";
IPlayer player = client.GetGrain <IPlayer>(playerId + Guid.NewGuid().ToString());
// Connect to a game
// TODO: Write a game creation grain for setting this up
Guid gameId = Guid.Empty;
IGame game = client.GetGrain <IGame>(gameId);
// Register to the game stream using the game id
// Streams are identified by stream IDs, which are just logical names comprised of GUIDs and strings.
IStreamProvider streamProvider = client.GetStreamProvider("GameStream");
IAsyncStream <GameMessage> gameStream = streamProvider.GetStream <GameMessage>(gameId, "game");
StreamSubscriptionHandle <GameMessage> handleGame = await gameStream.SubscribeAsync(new GameStreamObserver(client.ServiceProvider.GetService <ILoggerFactory>().CreateLogger("GameStreamObserver")));
IAsyncStream <GameMessage> actionStream = streamProvider.GetStream <GameMessage>(gameId, "actions");
StreamSubscriptionHandle <GameMessage> handleActions = await actionStream.SubscribeAsync(new GameStreamActionObserver(client.ServiceProvider.GetService <ILoggerFactory>().CreateLogger("GameStreamActionObserver")));
// For testing we're going to throw it all in a giant try catch >.<
// TODO: put in a testing framework.
try
{
await player.SetName("Rob Towell");
await game.Join(player);
await Task.Delay(2000);
await game.ProcessActionMessage(player, new MoveMessage()
{
PlayerId = player.GetPrimaryKeyString(), Direction = "left"
});
await Task.Delay(2000);
await game.Leave(player);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
// unsubscribe from the stream to clean up
await handleGame.UnsubscribeAsync();
await handleActions.UnsubscribeAsync();
Console.WriteLine("Work Completed");
}
