public static async Task Run([PerperStreamTrigger] PerperStreamContext context, [PerperStream("validatorRuntimeOutputStream")] IAsyncEnumerable <IHashed <AgentOutput> > validatorRuntimeOutputStream, [PerperStream("validatorFilterStream")] IAsyncEnumerable <IHashed <AgentOutput> > validatorFilterStream, [PerperStream("genesisStream")] IAsyncEnumerable <IHashed <AgentOutput> > genesisStream, [PerperStream("outputStream")] IAsyncCollector <Vote> outputStream, ILogger logger) { var state = await context.FetchStateAsync <State>() ?? new State(); await Task.WhenAll( validatorFilterStream.ForEachAsync(async proposal => { try { state.ExpectedNextSteps[proposal.Value.Previous] = proposal.Hash; await context.UpdateStateAsync(state); } catch (Exception e) { logger.LogError(e.ToString()); } }, CancellationToken.None), validatorRuntimeOutputStream.ForEachAsync(async step => { try { if (state.ExpectedNextSteps[step.Value.Previous] == step.Hash) { await outputStream.AddAsync(new Vote { For = step.Hash }); } else { logger.LogWarning("Got {hash}, expected {expected}", step.Hash, state.ExpectedNextSteps[step.Value.Previous]); } } catch (Exception e) { logger.LogError(e.ToString()); } }, CancellationToken.None), genesisStream.ForEachAsync(async step => { try { await outputStream.AddAsync(new Vote { For = step.Hash }); } catch (Exception e) { logger.LogError(e.ToString()); } }, CancellationToken.None)); }
public async Task Runtime( [PerperStreamTrigger] PerperStreamContext context, [Perper("agentDelegate")] string agentDelegate, [PerperStream("commands")] IAsyncEnumerable <AgentCommands> commands, CancellationToken cancellationToken) { await _testbed.Runtime(context, agentDelegate, commands, cancellationToken); }
public async Task Run([PerperStreamTrigger] PerperStreamContext context, [Perper("input")] IPerperStream input, [Perper("output")] IAsyncCollector <IPerperStream> output, ILogger logger, CancellationToken cancellationToken) { await output.AddAsync(input, cancellationToken); }
public async Task Run([PerperStreamTrigger] PerperStreamContext context, [Perper("proposerAccount")] Guid proposerAccount, [Perper("node")] Node node, [Perper("nodes")] List <Node> nodes, [Perper("chainData")] Chain chainData, [Perper("filter")] IAsyncEnumerable <Hash> filter, [Perper("validator")] IAsyncEnumerable <Message <Hash> > validator, [Perper("chain")] IAsyncEnumerable <Message <(Guid, Node?[])> > chain,
public static async Task Run([PerperStreamTrigger] PerperStreamContext context, [PerperStream("validatorSetsStream")] IAsyncEnumerable <IHashed <ValidatorSet> > validatorSetsStream, [PerperStream("commitsStream")] IAsyncEnumerable <ISigned <Commit> > commitsStream, [PerperStream("outputStream")] IAsyncCollector <ValidatorKey> outputStream, ILogger logger) { var state = await context.FetchStateAsync <State>() ?? new State(); await Task.WhenAll( validatorSetsStream.ForEachAsync(async validatorSet => { try { if (state.ValidatorSet == null) // HACK { // state.ValidatorSet.AccumulateWeights(); // state.ValidatorSet.PopMaxAccumulatedWeight(); var initialProposer = validatorSet.Value.Weights.Keys.First(); await outputStream.AddAsync(initialProposer); } state.ValidatorSet = validatorSet.Value; await context.UpdateStateAsync(state); } catch (Exception e) { logger.LogError(e.ToString()); } }, CancellationToken.None), commitsStream.ForEachAsync(async commit => { try { if (!state.Commits.ContainsKey(commit.Value.For)) { state.Commits[commit.Value.For] = new HashSet <ValidatorKey>(); } // TODO: Timeout proposers, rotate proposer only on his own blocks var wasMoreThanTwoThirds = state.ValidatorSet.IsMoreThanTwoThirds(state.Commits[commit.Value.For]); state.Commits[commit.Value.For].Add(commit.Signer); if (!wasMoreThanTwoThirds && state.ValidatorSet.IsMoreThanTwoThirds(state.Commits[commit.Value.For])) { // state.ValidatorSet.AccumulateWeights(); // state.ValidatorSet.PopMaxAccumulatedWeight(); var proposer = state.ValidatorSet.Weights.Keys.First(); await outputStream.AddAsync(proposer); } await context.UpdateStateAsync(state); } catch (Exception e) { logger.LogError(e.ToString()); } }, CancellationToken.None)); }
public static async Task Run([PerperStreamTrigger] PerperStreamContext context, [PerperStream("stepSignatureVerifierStream")] IAsyncEnumerable <IHashed <IAgentStep> > stepSignatureVerifierStream, [PerperStream("outputStream")] IAsyncCollector <Hash> outputStream) { await stepSignatureVerifierStream.ForEachAsync(async step => { await outputStream.AddAsync(step.Value.Previous); }, CancellationToken.None); }
public static async Task RunAsync([PerperStreamTrigger] PerperStreamContext context, [Perper("processor")] IAsyncEnumerable <object> processor, ILogger logger, CancellationToken cancellationToken) { await foreach (var data in processor.WithCancellation(cancellationToken)) { logger.LogInformation($"Consumer stream receives: {data}"); } }
public static async Task Run([PerperStreamTrigger] PerperStreamContext context, [PerperStream("validatorFilterStream")] IAsyncEnumerable <IHashed <AgentOutput> > validatorFilterStream, [PerperStream("outputStream")] IAsyncCollector <Hash> outputStream) { await validatorFilterStream.ForEachAsync(async output => { await outputStream.AddAsync(output.Value.Previous); }, CancellationToken.None); }
public static async Task RunAsync([PerperStreamTrigger] PerperStreamContext context, [Perper("processor")] IPerperStream processor, ILogger logger, CancellationToken cancellationToken) { logger.LogInformation($"Starting pass-through consumer"); await using var consumer = await context.StreamActionAsync("NamedConsumer", typeof(Consumer), new { processor = processor.Subscribe() }); await context.BindOutput(cancellationToken); }
public async Task AgentOne( [PerperStreamTrigger] PerperStreamContext context, [Perper("agentId")] string agentId, [Perper("initMessage")] object initMessage, [PerperStream("commands")] IAsyncEnumerable <AgentCommands> commands, [PerperStream("output")] IAsyncCollector <AgentCommands> output, CancellationToken cancellationToken) { await _testbed.Agent(new SingleAgent().Run, agentId, initMessage, commands, output, cancellationToken); }
public static async Task RunAsync([PerperStreamTrigger(RunOnStartup = true)] PerperStreamContext context, CancellationToken cancellationToken) { await context.StreamActionAsync("ChainList", new { chains = new Dictionary <byte[], string> { { new byte[0], typeof(AgentOneWrapper).FullName ! } } });
private async Task ExecuteAsync(string streamName, CancellationToken cancellationToken) { _logger.LogInformation($"Starting '{_delegateName}' as '{streamName}'"); var triggerValue = new PerperStreamContext(streamName, _delegateName, _context); var result = await _executor.TryExecuteAsync(new TriggeredFunctionData { TriggerValue = triggerValue }, cancellationToken); if (result.Exception != null && !(result.Exception is OperationCanceledException)) { _logger.LogError($"Exception while executing '{streamName}': {result.Exception.ToString()}"); } }
public async Task Run([PerperStreamTrigger] PerperStreamContext context, [Perper("input")] IAsyncEnumerable <IPerperStream> input, [Perper("output")] IAsyncCollector <IPerperStream> output, ILogger logger, CancellationToken cancellationToken) { var agentInput = await input.FirstAsync(cancellationToken); var agentStream = await context.StreamFunctionAsync(typeof(AgentPingStream), new { input = agentInput.Subscribe() }); await context.BindOutput(agentStream, cancellationToken); }
public static async Task Run([PerperStreamTrigger] PerperStreamContext context, [PerperStream("stepsStream")] IAsyncEnumerable <IHashed <AgentOutput> > stepsStream, [PerperStream("outputStream")] IAsyncCollector <ICommand> outputStream) { await stepsStream.ForEachAsync(async output => { foreach (var command in output.Value.Commands) { await outputStream.AddAsync(command); } }, CancellationToken.None); }
public async Task Run([PerperStreamTrigger] PerperStreamContext context, [Perper("agentPingOutput")] IAsyncEnumerable <string> agentPingOutput, [Perper("agentPongOutput")] IAsyncEnumerable <string> agentPongOutput, ILogger logger, CancellationToken cancellationToken) { await Task.WhenAll( agentPingOutput.ForEachAsync(message => logger.LogInformation($"Message in the environment: {message}"), cancellationToken), agentPongOutput.ForEachAsync(message => logger.LogInformation($"Message in the environment: {message}"), cancellationToken)); }
public static async Task Run([PerperStreamTrigger] PerperStreamContext context, [Perper("inputs")] IAsyncEnumerable <IPerperStream> inputs, ILogger logger, CancellationToken cancellationToken) { var outputs = new List <IPerperStream>(); await foreach (var input in inputs.WithCancellation(cancellationToken)) { logger.LogInformation($"Coallator receives input"); outputs.Add(input); await context.RebindOutput(outputs); } }
public async Task Run([PerperStreamTrigger] PerperStreamContext context, [Perper("input")] IAsyncEnumerable <string> input, [Perper("output")] IAsyncCollector <string> output, ILogger logger, CancellationToken cancellationToken) { await foreach (var message in input.WithCancellation(cancellationToken)) { logger.LogInformation($"AgentPong received {message}"); await PongAsync(output, cancellationToken); } }
public static async Task RunAsync([PerperStreamTrigger] PerperStreamContext context, [Perper("delay")] TimeSpan delay, [Perper("data")] object data, [PerperStream("outputStream")] IAsyncCollector <object> outputStream, ILogger logger) { await Task.Delay(delay); logger.LogDebug("Sending a {type}", data.GetType()); await outputStream.AddAsync(data); await context.BindOutput(CancellationToken.None); }
public static async Task Run([PerperStreamTrigger] PerperStreamContext context, [Perper("processor")] IAsyncEnumerable <Data> processor, [Perper("output")] IAsyncCollector <Data> output, ILogger logger, CancellationToken cancellationToken) { await foreach (var data in processor.WithCancellation(cancellationToken)) { logger.LogInformation($"CyclicGenerator stream receives: {data.Value}"); await Task.Delay(TimeSpan.FromSeconds(10), cancellationToken); await output.AddAsync(new Data { Value = data.Value / 10 }, cancellationToken); } }
public static async Task Run([PerperStreamTrigger] PerperStreamContext context, [PerperStream("commandsStream")] IAsyncEnumerable <ServiceCommand> commandsStream, [Perper("serviceName")] string serviceName, [PerperStream("outputStream")] IAsyncCollector <object> outputStream, CancellationToken cancellationToken) { await commandsStream.ForEachAsync(async command => { if (command.Service == serviceName) { await outputStream.AddAsync(command.Parameters); } }, cancellationToken); }
public static async Task Run([PerperStreamTrigger] PerperStreamContext context, [Perper("self")] ValidatorKey self, [Perper("privateKey")] ECParameters privateKey, [PerperStream("dataStream")] IAsyncEnumerable <object> dataStream, [PerperStream("outputStream")] IAsyncCollector <ISigned <object> > outputStream) { await dataStream.ForEachAsync(async item => { var bytes = IpfsJsonSettings.ObjectToBytes(item); var signature = ValidatorKey.GenerateSignature(privateKey, bytes); await outputStream.AddAsync(Signed.Create(item, self, signature)); }, CancellationToken.None); }
public async Task Run([PerperStreamTrigger] PerperStreamContext context, [Perper("enumerated")] IAsyncEnumerable <Message> enumerated, [Perper("filtered")] IAsyncEnumerable <Message> filtered, [Perper("queried")] IPerperStream[] queried, [Perper("i")] int i, [Perper("n")] int n, [Perper("output")] IAsyncCollector <Message> output) { await Task.WhenAll( ProcessEnumerated(i, enumerated), ProcessFiltered(i, filtered), ProcessQueried(i, queried.Select(stream => context.Query <Message>(stream))), SendOutput(i, n, output) ); }
public async Task Run([PerperStreamTrigger] PerperStreamContext context, [Perper("filter")] Type filter, [Perper("input")] IAsyncEnumerable <object> input, [Perper("output")] IAsyncCollector <HashRegistryEntry> output) { await foreach (var value in input) { if (filter.IsAssignableFrom(value.GetType())) { var hash = Hash.From(value); await output.AddAsync(new HashRegistryEntry(hash.ToString(), value)); } } }
public async Task Run([PerperStreamTrigger] PerperStreamContext context, [Perper("chains")] Dictionary <Guid, Chain> chains, [Perper("ibc")] IAsyncEnumerable <Message <Hash> > ibc, [Perper("gossips")] IAsyncEnumerable <Gossip <Hash> > gossips, [Perper("hashRegistry")] IPerperStream hashRegistry, [Perper("output")] IAsyncCollector <object> output, CancellationToken cancellationToken) { _hashRegistry = context.Query <HashRegistryEntry>(hashRegistry); _output = output; foreach (var(chainId, chain) in chains) { var executor = new Executor(chainId, async(worker, input) => await context.CallWorkerAsync <(byte[]?, (string, object[])[], Dictionary <Guid, string[]>, Dictionary <Guid, string>)>(worker, new { input }, default));
public static async Task Run([PerperStreamTrigger] PerperStreamContext context, [PerperStream("stepsStream")] IAsyncEnumerable <IHashed <IAgentStep> > stepsStream, [PerperStream("outputStream")] IAsyncCollector <Hash> outputStream, ILogger logger) { await stepsStream.ForEachAsync(async step => { if (step.Value.Previous != new Hash { Bytes = new byte[] {} }) { await outputStream.AddAsync(step.Value.PreviousValidatorSet); } }, CancellationToken.None); }
public static async Task Run([PerperStreamTrigger] PerperStreamContext context, CancellationToken cancellationToken) { ECParameters privateKey; ValidatorKey self; using (var dsa = ECDsa.Create()) { privateKey = dsa.ExportParameters(true); self = new ValidatorKey { Key = dsa.ExportParameters(false) }; } var ipfsGateway = "http://127.0.0.1:5001"; await using var agentZeroStream = await context.StreamFunctionAsync(nameof (IpfsInput), new { ipfsGateway, topic = "apocryph-agent-0" }); await using var _inputVerifierStream = await context.StreamFunctionAsync(nameof (StepSignatureVerifier), new { stepsStream = agentZeroStream, }); await using var inputVerifierStream = await context.StreamFunctionAsync(nameof (IpfsLoader), new { ipfsGateway, hashStream = _inputVerifierStream }); await using var validatorSetsStream = await context.StreamFunctionAsync(nameof (ValidatorSets), new { inputVerifierStream }); await using var validatorSchedulerStream = await context.StreamActionAsync(nameof (ValidatorScheduler), new { validatorSetsStream, ipfsGateway, privateKey, self }); await context.BindOutput(cancellationToken); }
public static async Task Run([PerperStreamTrigger(RunOnStartup = true)] PerperStreamContext context, CancellationToken cancellationToken) { var keys = new List <(ECParameters, ValidatorKey)>(); var validatorSet = new ValidatorSet(); for (var i = 0; i < 1; i++) { using var dsa = ECDsa.Create(ECCurve.NamedCurves.nistP521); var privateKey = dsa.ExportParameters(true); var publicKey = new ValidatorKey { Key = dsa.ExportParameters(false) }; keys.Add((privateKey, publicKey)); validatorSet.Weights.Add(publicKey, 10); } var ipfsGateway = "http://127.0.0.1:5001"; await using var _validatorSetsStream = await context.StreamFunctionAsync("TestDataGenerator", new { delay = TimeSpan.FromSeconds(20), data = validatorSet }); await using var validatorSetsStream = await context.StreamFunctionAsync(nameof (IpfsSaver), new { ipfsGateway, dataStream = _validatorSetsStream }); await using var validatorLauncherStreams = new AsyncDisposableList(); foreach (var(privateKey, self) in keys) { validatorLauncherStreams.Add( await context.StreamActionAsync(nameof(ValidatorLauncher), new { agentId = "0", services = new [] { "Sample", "IpfsInput" }, validatorSetsStream, ipfsGateway, privateKey, self })); } await context.BindOutput(cancellationToken); }
public static async Task Run([PerperStreamTrigger] PerperStreamContext context, [PerperStream("validatorSetsStream")] IAsyncEnumerable <IHashed <ValidatorSet> > validatorSetsStream, [PerperStream("commitsStream")] IAsyncEnumerable <ISigned <Commit> > commitsStream, [PerperStream("outputStream")] IAsyncCollector <Hash> outputStream, ILogger logger) { var state = await context.FetchStateAsync <State>() ?? new State(); await Task.WhenAll( validatorSetsStream.ForEachAsync(async validatorSet => { try { state.ValidatorSet = validatorSet.Value; await context.UpdateStateAsync(state); } catch (Exception e) { logger.LogError(e.ToString()); } }, CancellationToken.None), commitsStream.ForEachAsync(async commit => { try { if (!state.Commits.ContainsKey(commit.Value.For)) { state.Commits[commit.Value.For] = new HashSet <ValidatorKey>(); } var wasMoreThanTwoThirds = state.ValidatorSet.IsMoreThanTwoThirds(state.Commits[commit.Value.For]); state.Commits[commit.Value.For].Add(commit.Signer); await context.UpdateStateAsync(state); if (!wasMoreThanTwoThirds && state.ValidatorSet.IsMoreThanTwoThirds(state.Commits[commit.Value.For])) { await outputStream.AddAsync(commit.Value.For); } } catch (Exception e) { logger.LogError(e.ToString()); } }, CancellationToken.None)); }
public async Task Run([PerperStreamTrigger] PerperStreamContext context, [Perper("node")] Node node, [Perper("chainData")] Chain chainData, [Perper("consensus")] IAsyncEnumerable <Message <Hash> > consensus, [Perper("filter")] IAsyncEnumerable <Hash> filter, [Perper("queries")] IAsyncEnumerable <Query <Hash> > queries, [Perper("hashRegistry")] IPerperStream hashRegistry, [Perper("output")] IAsyncCollector <Message <Hash> > output, CancellationToken cancellationToken) { _output = output; _node = node; _hashRegistry = context.Query <HashRegistryEntry>(hashRegistry); var executor = new Executor(_node !.ChainId, async(worker, input) => await context.CallWorkerAsync <(byte[]?, (string, object[])[], Dictionary <Guid, string[]>, Dictionary <Guid, string>)>(worker, new { input }, default));
public async Task Run([PerperStreamTrigger] PerperStreamContext context, [Perper("factory")] IAsyncEnumerable <IPerperStream> factory, [Perper("initial")] IEnumerable <IPerperStream> initial, CancellationToken cancellationToken) { var output = initial.ToList(); await context.RebindOutput(output); var peers = factory; //.Where(stream => stream.GetDelegate() == filter); await foreach (var peer in peers.WithCancellation(cancellationToken)) { output.Add(peer); await context.RebindOutput(output); } }