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