Question about grain versioning

[horacioj]

Hello,

I've read about Grain interface versioning but I still have some doubts. If someone can validate if I'm doing things the right way, it would be very helpful.

Let's say I have a grain interface like this (already in production):

public interface IMyGrain : IGrainWithStringKey
{
    Task MyMethod(ISomething something);

    Task<AnObject> MyOtherMethod(string aaa, int bbb);
}

And an implementation like this (already in production):

public class MyClass : IMyGrain
{
    public Task MyMethod(ISomething something)
    {
        // some stuff is done here
    }

    public Task<AnObject> MyOtherMethod(string aaa, int bbb)
    {
        // some stuff is done here
        return anObject;
    }
}

The business requirements changed, and now the interface (and its implementation) must change.

This is how I'm implementing the change, but I'm not sure if it is right.
Even if it is 'rightish', it doesn't feel right because I don't like having to create a new method name and replace every call to point to the new name.

The updated interface:

[Version(2)]
public interface IMyGrain : IGrainWithStringKey
{
    [Obsolete("Use MyMethodV2 instead")]
    Task MyMethod(ISomething something);

    [Obsolete("Use MyOtherMethodV2 instead")]
    Task<AnObject> MyOtherMethod(string aaa, int bbb);

    Task<ThrdThing> MyMethodV2(ISomething something);

    Task<SomeOtherThing> MyOtherMethodV2(string aaa, int bbb);
}

The updated implementation:

public class MyClass : IMyGrain
{
    public Task MyMethod(ISomething something)
        => MyMethodV2(something)

    public async Task<AnObject> MyOtherMethod(string aaa, int bbb);
    {
        var result = await MyOtherMethodV2(aaa, bbb);
      
        // based on 'result' build an 'AnObject' and return it
        ....
        ....
        return anObject;
    }

    public Task<TrdThing> MyMethodV2(ISomething something)
    {
        // new implementation
        return trdThing;
    }

    public Task<SomeOtherThing> MyOtherMethodV2(string aaa, int bbb)
    {
        // new implementation
        return someOtherThing;
    }
}

Am I doing things right? Will the new implementation not break production once it is deployed?

Thanks!

[ReubenBond]

What you have looks good to me, @horacioj. You have kept the previous methods without changing their signature, and presumably only changing their behavior in a backwards compatible manner (so v1 clients will still receive the expected result).

[horacioj]

Thank you, @ReubenBond !

[horacioj]

I have a doubt, related to this.

Given the way I've implemented the new version of the grain, is the following safe & ok?

//NOTE: https://learn.microsoft.com/en-us/dotnet/orleans/grains/grain-versioning/grain-versioning
silo.Configure<GrainVersioningOptions>(options =>
{
	options.DefaultCompatibilityStrategy = nameof(BackwardCompatible);
	options.DefaultVersionSelectorStrategy = nameof(LatestVersion);
});

I'm 99% sure BackwardCompatible is fine.
My main doubt is about LatestVersion vs the default AllCompatibleVersions.
What I want is every activation to use the newer implementation as soon as possible.
Could LatestVersion break something or is it ok?

[horacioj]

Now I think it should be AllCompatibleVersions, not LatestVersion, but I'm still unsure.

What makes me doubt is "there is a 20% chance that the new activation will be a V2 and an 80% chance that it will be a V1" at https://learn.microsoft.com/en-us/dotnet/orleans/grains/grain-versioning/version-selector-strategy