.NET分布式Orleans - 6 - 事件溯源

<PackageReference Include="Microsoft.Orleans.EventSourcing" Version="8.0.0" />
<PackageReference Include="Microsoft.Orleans.Clustering.AdoNet" Version="8.0.0" />
<PackageReference Include="Microsoft.Orleans.Persistence.AdoNet" Version="8.0.0" />
<PackageReference Include="Microsoft.Orleans.Server" Version="8.0.0" />

builder.Host.UseOrleans(static siloHostBuilder =>
{
    var invariant = "System.Data.SqlClient";

    var connectionString = "Data Source=localhost\\SQLEXPRESS;Initial Catalog=orleanstest;User Id=sa;Password=12334;";

    siloHostBuilder.AddLogStorageBasedLogConsistencyProvider("LogStorage");

    // Use ADO.NET for clustering
    siloHostBuilder.UseAdoNetClustering(options =>
    {
        options.Invariant = invariant;
        options.ConnectionString = connectionString;
    }).ConfigureLogging(logging => logging.AddConsole());

    siloHostBuilder.Configure<ClusterOptions>(options =>
    {
        options.ClusterId = "my-first-cluster";
        options.ServiceId = "SampleApp";
    });

    // Use ADO.NET for persistence
    siloHostBuilder.AddAdoNetGrainStorage("GrainStorageForTest", options =>
    {
        options.Invariant = invariant;
        options.ConnectionString = connectionString;
        //options.GrainStorageSerializer = new JsonGrainStorageSerializer()
     
    });
});

// the classes below represent events/transactions on the account
// all fields are user-defined (none have a special meaning),
// so these can be any type of object you like, as long as they are serializable
// (so they can be sent over the wire and persisted in a log).

[Serializable]
[GenerateSerializer]
public abstract class Transaction
{
    /// <summary> A unique identifier for this transaction  </summary>
    [Id(0)]
    public Guid Guid { get; set; }

    /// <summary> A description for this transaction  </summary>
    [Id(1)]
    public string Description { get; set; }

    /// <summary> time on which the request entered the system  </summary>
    [Id(2)]
    public DateTime IssueTime { get; set; }
}

[Serializable]
[GenerateSerializer]
public class DepositTransaction : Transaction
{
    [Id(0)]
    public uint DepositAmount { get; set; }
}

[Serializable]
[GenerateSerializer]
public class WithdrawalTransaction : Transaction
{
    [Id(0)]
    public uint WithdrawalAmount { get; set; }
}

/// <summary>
/// An example of a journaled grain that models a bank account.
/// 
/// Configured to use the default storage provider.
/// Configured to use the LogStorage consistency provider.
/// 
/// This provider persists all events, and allows us to retrieve them all.
/// </summary>

/// <summary>
/// A grain that models a bank account
/// </summary>
public interface IAccountGrain : IGrainWithStringKey
{
    Task<uint> Balance();

    Task Deposit(uint amount, Guid guid, string desc);

    Task<bool> Withdraw(uint amount, Guid guid, string desc);

    Task<IReadOnlyList<Transaction>> GetTransactionLog();
}

[StorageProvider(ProviderName = "GrainStorageForTest")]
[LogConsistencyProvider(ProviderName = "LogStorage")]

public class AccountGrain : JournaledGrain<AccountGrain.GrainState, Transaction>, IAccountGrain
{
    /// <summary>
    /// The state of this grain is just the current balance.
    /// </summary>
    [Serializable]
    [Orleans.GenerateSerializer]
    public class GrainState
    {
        [Orleans.Id(0)]
        public uint Balance { get; set; }

        public void Apply(DepositTransaction d)
        {
            Balance = Balance + d.DepositAmount;
        }

        public void Apply(WithdrawalTransaction d)
        {
            if (d.WithdrawalAmount > Balance)
                throw new InvalidOperationException("we make sure this never happens");

            Balance = Balance - d.WithdrawalAmount;
        }
    }

    public Task<uint> Balance()
    {
        return Task.FromResult(State.Balance);
    }

    public Task Deposit(uint amount, Guid guid, string description)
    {
        RaiseEvent(new DepositTransaction()
        {
            Guid = guid,
            IssueTime = DateTime.UtcNow,
            DepositAmount = amount,
            Description = description
        });

        // we wait for storage ack
        return ConfirmEvents();
    }

    public Task<bool> Withdraw(uint amount, Guid guid, string description)
    {
        // if the balance is too low, can't withdraw
        // reject it immediately
        if (State.Balance < amount)
            return Task.FromResult(false);

        // use a conditional event for withdrawal
        // (conditional events commit only if the version hasn't already changed in the meantime)
        // this is important so we can guarantee that we never overdraw
        // even if racing with other clusters, of in transient duplicate grain situations
        return RaiseConditionalEvent(new WithdrawalTransaction()
        {
            Guid = guid,
            IssueTime = DateTime.UtcNow,
            WithdrawalAmount = amount,
            Description = description
        });
    }

    public Task<IReadOnlyList<Transaction>> GetTransactionLog()
    {
        return RetrieveConfirmedEvents(0, Version);
    }
}

var palyer = client.GetGrain<IAccountGrain>("zhangsan");
await palyer.Deposit(1000, Guid.NewGuid(), "aaa");
var logs = await palyer.GetTransactionLog();
return Results.Ok(logs);