コード例 #1
0
        public static async Task RunAsync([PerperModuleTrigger(RunOnStartup = true)]
                                          PerperModuleContext context,
                                          CancellationToken cancellationToken)
        {
            await using var multiGenerator =
                            await context.StreamFunctionAsync("NamedGeneratorGenerator", typeof(GeneratorGenerator), new { count = 40 });

            await using var coallator =
                            await context.StreamFunctionAsync("NamedCoallator", typeof(Coallator), new { inputs = multiGenerator.Subscribe() });

            await using var consumer =
                            await context.StreamActionAsync("NamedPassthroughConsumer", typeof(PassthroughConsumer), new { processor = coallator });

            await context.BindOutput(cancellationToken);
        }
コード例 #2
0
        public static async Task RunAsync([PerperModuleTrigger(RunOnStartup = true)]
                                          PerperModuleContext context,
                                          CancellationToken cancellationToken)
        {
            var slotCount = 20; // 30

            var pingChainId = Guid.NewGuid();
            var pongChainId = Guid.NewGuid();

            // For test harness we create seed blocks with valid references in the states
            var pingReference = Guid.NewGuid();
            var pongReference = Guid.NewGuid();

            var slotGossips = await context.StreamFunctionAsync("DummyStream", new { });

            await context.StreamActionAsync("Apocryph.Runtime.FunctionApp.ChainListStream.Run", new
            {
                slotGossips,
                chains = new Dictionary <Guid, Chain>
                {
                    { pingChainId, new Chain(slotCount, new Block(
                                                 new Hash(new byte[] {}),
                                                 pingChainId,
                                                 null,
                                                 Guid.NewGuid(),
                                                 new Dictionary <string, byte[]>
                        {
                            {
                                typeof(ChainAgentPing).FullName !+".Run",
                                JsonSerializer.SerializeToUtf8Bytes(new ChainAgentState {
                                    OtherReference = pongReference
                                })
                            },
コード例 #3
0
        public async Task <IPerperStream> StartAsync(
            [PerperModuleTrigger] PerperModuleContext context,
            [Perper("input")] IPerperStream input,
            CancellationToken cancellationToken,
            ILogger logger)
        {
            logger.LogInformation("Started AgentPong module...");

            var runtimeStream = await context.StreamFunctionAsync(typeof(AgentPongRuntimeStream), new { input = input.Subscribe() });

            return(runtimeStream);
        }
コード例 #4
0
        public async Task StartAsync(
            [PerperModuleTrigger(RunOnStartup = true)] PerperModuleContext context,
            CancellationToken cancellationToken,
            ILogger logger)
        {
            logger.LogInformation("Started Perper Structure sample application...");

            var pingInputStream  = context.DeclareStream(typeof(InputProviderStream));
            var pingOutputStream = await context.StartChildModuleAsync <IPerperStream>("ping", new { input = pingInputStream }, cancellationToken);

            var pongInputStream  = context.DeclareStream(typeof(InputProviderStream));
            var pongOutputStream = await context.StartChildModuleAsync <IPerperStream>("pong", new { input = pongInputStream }, cancellationToken);

            await context.StreamFunctionAsync(pingInputStream, new { input = pongOutputStream });

            await context.StreamFunctionAsync(pongInputStream, new { input = pingOutputStream });

            await context.StreamActionAsync(typeof(EnvironmentMonitorStream),
                                            new
            {
                agentPingOutput = pingOutputStream.Subscribe(),
                agentPongOutput = pongOutputStream.Subscribe()
            });
        }
コード例 #5
0
ファイル: Launcher.cs プロジェクト: sbnair/perper
        public async Task Run([PerperModuleTrigger(RunOnStartup = true)] PerperModuleContext context,
                              CancellationToken cancellationToken)
        {
            var streams = new List <IPerperStream>();

            for (var i = 0; i < NodeCount; i++)
            {
                var stream = context.DeclareStream("Node-" + i, typeof(Node), typeof(Message));
                streams.Add(stream);
            }

            var peering = await context.StreamFunctionAsync("Peering", typeof(Peering), new
            {
                streams = streams.ToArray()
            }, typeof(Message));

            var dummy = await context.StreamFunctionAsync("DummyInput", "Dummy", new { }, typeof(Message));

            for (var i = 0; i < NodeCount; i++)
            {
                await context.StreamFunctionAsync(streams[i], new
                {
                    enumerated = (EnumerateMessages ? peering : dummy).Subscribe(),
                    filtered   = (FilterMessages ? peering : dummy).Filter("To", i).Subscribe(),
                    queried    = (QueryMessages ? streams.ToArray() : new IPerperStream[0] {
                    }),
                    i,
                    n = NodeCount,
                });
            }

            await context.StreamActionAsync("Dummy", new
            {
                peering = peering.Subscribe()
            });

            while (!NodesReady.IsMax())
            {
                await Task.Delay(100);
            }
            var columns = "| {0,10}";

            if (EnumerateMessages)
            {
                columns += " | {1,10}";
            }
            if (FilterMessages)
            {
                columns += " | {2,10}";
            }
            if (QueryMessages)
            {
                columns += " | {3,10}";
            }
            columns += " | {4,10} |";
            var stats   = new[] { MessagesSent.Read(), MessagesEnumerated.Read(), MessagesFiltered.Read(), MessagesQueried.Read(), MessagesProcessed.Read() };
            var seconds = 0;

            Console.WriteLine("Sending {0} messages between {1} nodes", MessagesSent.Max, NodesReady.Max);
            Console.WriteLine("Per-second values:");
            Console.WriteLine(columns, "Sent", "Enumerated", "Filtered", "Queried", "Processed");
            Console.WriteLine(columns, "-", "-", "-", "-", "-");
            while (true)
            {
                seconds += 1;
                cancellationToken.ThrowIfCancellationRequested();
                await Task.Delay(1000, cancellationToken);

                var values = stats.Select(x => (object)x.Advance()).ToArray();
                Console.WriteLine(columns, values);

                if ((long)values[4] == 0L)
                {
                    break; // Nothing processed in the last second, assume finished
                }
            }
            Console.WriteLine("Sent {0} messages between {1} nodes in roughly {2} seconds", MessagesSent.Get(), NodesReady.Get(), seconds);
        }