Azure service fabric actor dependency injection

Question

Is there any way to inject dependencies in to the Azure Service Fabric Actor\'s constructor?

Answer 1

If you're using Autofac, they have a specific integration package for that:

https://alexmg.com/introducing-the-autofac-integration-for-service-fabric/ https://www.nuget.org/packages/Autofac.ServiceFabric/

In short, registration is performed using ActorRuntime.RegisterActorAsync / ServiceRuntime.RegisterServiceAsync as you would expect. However the more problematic part, namely object release, is automatically handled in the OnDeactivateAsync / OnCloseAsync / OnAbort overrides using a dynamic proxy. Proper lifetime scoped is maintained as well.

At the time of writing it's still in Alpha though (just released last month).

Answer 2

Having had a bit of a dig-around in this area with dotPeek a while back (trying to resolve actors from an Autofac lifetime scope per-invocation), I think the trick is to create your own implementation of StatelessActorServiceFactory, and your own extension method to register the actor with it. Although the factory class is marked as internal, its interface (IStatelessServiceFactory) and the service type it creates (StatelessActorServiceInstance) are both public. Unfortunately, it doesn't look like StatelessActorServiceInstance was designed to be extensible (I'm hoping this is just an oversight).

Unfortunately, it looks like WcfActorCommunicationProvider is also marked as internal so you'll pretty much have to create your own pipeline from scratch:

1. Implement your own IStatelessServiceFactory
2. Implement your own IStatelessServiceInstance, IActorService
3. Implement your own IActorCommunicationProvider
4. Implement your own IActorHost

Doesn't really seem worth the effort anymore, does it? :-/

That's where I gave up for now. I don't think it's worth trying to roll-your-own for now given the relative immaturity of the public API, since if this sort of functionality will show up at all, they'll probably do so in a way that'll break anything your implement yourself.

Answer 3

Updated

Its all on github and myget now: https://github.com/s-innovations/S-Innovations.ServiceFabric.Unity

and integrates with aspnet core dependency injection without to much hassle, check the examples of the readme.md

---

I am a long time user of Unity and decided to make the core extension methods needed to have a nice dependency injection experience when working with actors.

My program.cs now looks like this:

internal static class Program
{
    /// <summary>
    /// This is the entry point of the service host process.
    /// </summary>
    private static void Main()
    {
        try
        {
            using (var container = new UnityContainer())
            {
                container.RegisterType<IMessageProcessorClientFactory, DummyFactory>(new HierarchicalLifetimeManager());
                container.RegisterType<IMessageClusterConfigurationStore, test>(new HierarchicalLifetimeManager());

                container.WithFabricContainer();
                container.WithActor<MessageClusterActor>();
                container.WithActor<QueueListenerActor>();
                container.WithStatelessFactory<ManagementApiServiceFactory>("ManagementApiServiceType");
                container.WithActor<VmssManagerActor>();

                ServiceFabricEventSource.Current.ServiceTypeRegistered(Process.GetCurrentProcess().Id, typeof(ManagementApiService).Name);

                Thread.Sleep(Timeout.Infinite);  // Prevents this host process from terminating to keep the service host process running.
            }
        }
        catch (Exception e)
        {
            ServiceFabricEventSource.Current.ActorHostInitializationFailed(e.ToString());
            throw;
        }
    }
}

where I in actors and services can just put in my dependencies in the constructors.

public class VmssManagerActor : StatefulActor<VmssManagerActor.ActorState>, IVmssManagerActor, IRemindable
{
    public const string CheckProvision = "CheckProvision";

    /// <summary>
    /// Cluster Configuration Store
    /// </summary>       
    protected IMessageClusterConfigurationStore ClusterConfigStore { get; private set; }

    public VmssManagerActor(IMessageClusterConfigurationStore clusterProvider)
    {
        ClusterConfigStore = clusterProvider;
    }

If you feel this is useful and would like me to put it into a nuget package, upvote this answer.

One note about the implementation, each actor will get its own scope. This means that all dependencies registered with 'HierarchicalLifetimeManager' that implements IDisposable will automaticly get disposed in the actor OnDeactivationAsync. This was done by dynamicly proxying the actor class with a dynamic type that intercepts the call to OnDeactivationAsync. For this to work the Actor must be public defined.

IActorDeactivationInterception.cs

namespace SInnovations.Azure.ServiceFabric.Unity.Abstraction
{
    /// <summary>
    /// The <see cref="IActorDeactivationInterception"/> interface for defining an OnDeactivateInterception
    /// </summary>
    public interface IActorDeactivationInterception
    {
        void Intercept();
    }
}

ActorProxyTypeFactory.cs

namespace SInnovations.Azure.ServiceFabric.Unity.Actors
{
    using System;
    using System.Linq;
    using System.Reflection;
    using System.Reflection.Emit;
    using SInnovations.Azure.ServiceFabric.Unity.Abstraction;

    public class ActorProxyTypeFactory
    {
        /// <summary>
        /// Creates a new instance of the <see cref="ActorProxyTypeFactory"/> class.
        /// </summary>
        /// <param name="target"></param>
        public ActorProxyTypeFactory(Type target)
        {
            this.target = target;
        }

        /// <summary>
        /// Creates the proxy registered with specific interceptor.
        /// </summary>
        /// <returns></returns>
        public static T Create<T>(IActorDeactivationInterception deactivation, params object[] args)
        {
            return (T)new ActorProxyTypeFactory(typeof(T)).Create(new object[] { deactivation }.Concat(args).ToArray());
        }
        public static Type CreateType<T>()
        {
            return new ActorProxyTypeFactory(typeof(T)).CreateType();
        }
        /// <summary>
        /// Creates the proxy registered with specific interceptor.
        /// </summary>
        /// <returns></returns>
        public object Create(object[] args)
        {
            BuidAssembly();
            BuildType();
            InterceptAllMethods();

            Type proxy = this.typeBuilder.CreateType();

            return Activator.CreateInstance(proxy, args);
        }

        public Type CreateType()
        {
            BuidAssembly();
            BuildType();
            InterceptAllMethods();

            Type proxy = this.typeBuilder.CreateType();
            return proxy;
            //  return Activator.CreateInstance(proxy, args);
        }

        /// <summary>
        /// Builds a dynamic assembly with <see cref="AssemblyBuilderAccess.RunAndSave"/> mode.
        /// </summary>
        /// <returns></returns>
        public void BuidAssembly()
        {
            AssemblyName assemblyName = new AssemblyName("BasicProxy");
            AssemblyBuilder createdAssembly = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
            // define module
            this.moduleBuilder = createdAssembly.DefineDynamicModule(assemblyName.Name);
        }

        public void BuildType()
        {
            if (!target.IsPublic)
            {
                throw new ArgumentException("Actors have to be public defined to proxy them");
            }


            this.typeBuilder =
                this.moduleBuilder.DefineType(target.FullName + "Proxy", TypeAttributes.Class | TypeAttributes.Public, target);
            this.fldInterceptor = this.typeBuilder.DefineField("interceptor", typeof(IActorDeactivationInterception), FieldAttributes.Private);

            foreach (var constructor in target.GetConstructors())
            {
                //  Type[] parameters = new Type[1];

                ParameterInfo[] parameterInfos = constructor.GetParameters();
                Type[] parameters = new Type[parameterInfos.Length + 1];

                parameters[0] = typeof(IActorDeactivationInterception);


                for (int index = 1; index <= parameterInfos.Length; index++)
                {
                    parameters[index] = parameterInfos[index - 1].ParameterType;
                }

                ConstructorBuilder constructorBuilder =
                    typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, parameters);

                for (int argumentIndex = 0; argumentIndex < parameters.Length; argumentIndex++)
                    constructorBuilder.DefineParameter(
                        argumentIndex + 1,
                        ParameterAttributes.None,
                        $"arg{argumentIndex}");

                ILGenerator generator = constructorBuilder.GetILGenerator();

                generator.Emit(OpCodes.Ldarg_0);

                for (int index = 1; index < parameters.Length; index++)
                {
                    generator.Emit(OpCodes.Ldarg, index + 1);
                }

                generator.Emit(OpCodes.Call, constructor);

                generator.Emit(OpCodes.Ldarg_0);
                generator.Emit(OpCodes.Ldarg_1);
                generator.Emit(OpCodes.Stfld, fldInterceptor);
                generator.Emit(OpCodes.Ret);
            }
        }

        /// <summary>
        /// Builds a type in the dynamic assembly, if already the type is not created.
        /// </summary>
        /// <returns></returns>
        public void InterceptAllMethods()
        {

            const MethodAttributes targetMethodAttributes =
                MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.HideBySig;

            var methodInfo = target.GetMethod("OnDeactivateAsync", BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.FlattenHierarchy);
            {
                if (methodInfo.IsVirtual)
                {
                    Type[] paramTypes = GetParameterTypes(methodInfo.GetParameters());

                    MethodBuilder methodBuilder =
                        typeBuilder.DefineMethod(methodInfo.Name, targetMethodAttributes, methodInfo.ReturnType, paramTypes);

                    ILGenerator ilGenerator = methodBuilder.GetILGenerator();


                    ilGenerator.Emit(OpCodes.Ldarg_0);
                    ilGenerator.Emit(OpCodes.Ldfld, fldInterceptor);
                    ilGenerator.Emit(OpCodes.Call, typeof(IActorDeactivationInterception).GetMethod("Intercept"));

                    ilGenerator.Emit(OpCodes.Ldarg_0);
                    ilGenerator.Emit(OpCodes.Call, methodInfo);
                    ilGenerator.Emit(OpCodes.Ret);

                    return;


                }
            }
        }



        private Type[] GetParameterTypes(ParameterInfo[] parameterInfos)
        {
            Type[] parameters = new Type[parameterInfos.Length];

            int index = 0;

            foreach (var parameterInfo in parameterInfos)
            {
                parameters[index++] = parameterInfo.ParameterType;
            }
            return parameters;
        }

        private TypeBuilder typeBuilder;
        private ModuleBuilder moduleBuilder;
        private readonly Type target;
        private FieldInfo fldInterceptor;

    }

}

OnActorDeactivateInterceptor.cs

namespace SInnovations.Azure.ServiceFabric.Unity.Actors
{
    using Microsoft.Practices.Unity;
    using SInnovations.Azure.ServiceFabric.Unity.Abstraction;

    public class OnActorDeactivateInterceptor : IActorDeactivationInterception
    {
        private readonly IUnityContainer container;
        public OnActorDeactivateInterceptor(IUnityContainer container)
        {
            this.container = container;
        }

        public void Intercept()
        {
            this.container.Dispose();
        }
    }
}

UnityFabricExtensions.cs

namespace SInnovations.Azure.ServiceFabric.Unity
{
    using System;
    using System.Fabric;
    using Microsoft.Practices.Unity;
    using Microsoft.ServiceFabric.Actors;
    using SInnovations.Azure.ServiceFabric.Unity.Abstraction;
    using SInnovations.Azure.ServiceFabric.Unity.Actors;

    public static class UnityFabricExtensions
    {
        public static IUnityContainer WithFabricContainer(this IUnityContainer container)
        {
            return container.WithFabricContainer(c => FabricRuntime.Create());
        }
        public static IUnityContainer WithFabricContainer(this IUnityContainer container, Func<IUnityContainer,FabricRuntime> factory)
        {
            container.RegisterType<FabricRuntime>(new ContainerControlledLifetimeManager(), new InjectionFactory(factory));
            return container;
        }

        public static IUnityContainer WithActor<TActor>(this IUnityContainer container) where TActor : ActorBase
        {
            if (!container.IsRegistered<IActorDeactivationInterception>())
            {
                container.RegisterType<IActorDeactivationInterception, OnActorDeactivateInterceptor>(new HierarchicalLifetimeManager());
            }

            container.RegisterType(typeof(TActor), ActorProxyTypeFactory.CreateType<TActor>(),new HierarchicalLifetimeManager());
            container.Resolve<FabricRuntime>().RegisterActorFactory(() => {
                try {
                    var actor = container.CreateChildContainer().Resolve<TActor>();
                    return actor;
                }
                catch (Exception ex)
                {
                    throw;
                }
                });

            return container;
        }


        public static IUnityContainer WithStatelessFactory<TFactory>(this IUnityContainer container, string serviceTypeName) where TFactory : IStatelessServiceFactory
        {
            if (!container.IsRegistered<TFactory>())
            {
                container.RegisterType<TFactory>(new ContainerControlledLifetimeManager());
            }
            container.Resolve<FabricRuntime>().RegisterStatelessServiceFactory(serviceTypeName, container.Resolve<TFactory>());
            return container;
        }
        public static IUnityContainer WithStatefulFactory<TFactory>(this IUnityContainer container, string serviceTypeName) where TFactory : IStatefulServiceFactory
        {
            if (!container.IsRegistered<TFactory>())
            {
                container.RegisterType<TFactory>(new ContainerControlledLifetimeManager());
            }
            container.Resolve<FabricRuntime>().RegisterStatefulServiceFactory(serviceTypeName, container.Resolve<TFactory>());
            return container;
        }
        public static IUnityContainer WithService<TService>(this IUnityContainer container, string serviceTypeName) 
        {
            container.Resolve<FabricRuntime>().RegisterServiceType(serviceTypeName, typeof(TService));
            return container;
        }
    }
}

Answer 4

@abatishchev I think you are referring to the Service-Locator antipattern. Both Dependency Injection and Service-Locator are variations of Inversion of Control.

https://www.martinfowler.com/articles/injection.html

Answer 5

I know this is old but for documentations' sake DI is now supported in the Reliable Actor framework just like you would expect.

public class ActorOne : Actor<MyActorState>, IMyActor{

private readonly IDependency _dependency;

public ActorOne(IDependency dependency)
{
    _dependency = dependency;
}}

And then you register the Actor with its dependency with the Service Fabric like this:

using (FabricRuntime fRuntime = FabricRuntime.Create()){

fRuntime.RegisterActor(() => new ActorOne(new MyDependency());
Thread.Sleep(Timeout.Infinite);}

Answer 6

Why not just use some root element field in actor, and resolve it from container with injected dependencies in Actor's constructor? If this is a bad decision, please explain why:

public class StatelessActor2 : Actor, IStatelessActor2
{
    private ConfiguredContainer _container;
    private IRootElement _rootElement;

    public StatelessActor2()

    {
        _container = new ConfiguredContainer(); //... container is configured in it's constructor
        _rootElement = _container.Resolve<IRootElement>();
    }

    public async Task<string> DoWorkAsync()
    {
        // Working with a RootElement with all dependencies are injected..
        return await Task.FromResult(_rootElement.WorkingWithInjectedStuff());
    }
}