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"); }