4449659504

Build Type

push

github

Committed by

Commit Message

Rename worker builder methods

Run Details

6 of 6 new or added lines in 1 file covered. (100.0%)

2294 of 2775 relevant lines covered (82.67%)

143.65 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

79.03

/src/LLL.DurableTask.Worker/Builder/DurableTaskWorkerBuilderExtensions.cs


using System;
using System.Threading.Tasks;
using DurableTask.Core;
using DurableTask.Core.Middleware;
using LLL.DurableTask.Worker.Orchestrations;
using LLL.DurableTask.Worker.Builder;
using System.Reflection;
using LLL.DurableTask.Worker.Attributes;

namespace Microsoft.Extensions.DependencyInjection
{
    public static class DurableTaskWorkerBuilderExtensions
    {
        public static IDurableTaskWorkerBuilder AddAnnotatedFrom(
            this IDurableTaskWorkerBuilder builder,
            Assembly assembly)
        {
            return builder
                .AddAnnotatedOrchestrationsFrom(assembly)
                .AddAnnotatedActivitiesFrom(assembly);
        }

        public static IDurableTaskWorkerBuilder AddAnnotatedFrom(
            this IDurableTaskWorkerBuilder builder,
            Type type)
        {
            return builder
                .AddAnnotatedOrchestrationsFrom(type)
                .AddAnnotatedActivitiesFrom(type);
        }

        public static IDurableTaskWorkerBuilder AddAnnotatedOrchestrationsFrom(
            this IDurableTaskWorkerBuilder builder,
            Assembly assembly)
        {
            foreach (var type in assembly.GetTypes())
                builder.AddAnnotatedOrchestrationsFrom(type);
            return builder;
        }

        public static IDurableTaskWorkerBuilder AddAnnotatedOrchestrationsFrom(
            this IDurableTaskWorkerBuilder builder,
            Type type)
        {
            var typeOrchestrationAttribute = type.GetCustomAttribute<OrchestrationAttribute>();
            if (typeOrchestrationAttribute != null)
            {
                builder.AddOrchestration(type, typeOrchestrationAttribute.Name, typeOrchestrationAttribute.Version);
            }
            foreach (var methodInfo in type.GetMethods())
            {
                var orchestrationAttribute = methodInfo.GetCustomAttribute<OrchestrationAttribute>();
                if (orchestrationAttribute != null)
                {
                    builder.AddOrchestrationMethod(type, methodInfo, orchestrationAttribute.Name, orchestrationAttribute.Version);
                }
            }
            return builder;
        }

        public static IDurableTaskWorkerBuilder AddOrchestrationMethod(
            this IDurableTaskWorkerBuilder builder,
            Type type,
            MethodInfo methodInfo,
            string name = null,
            string version = null)
        {
            return builder.AddOrchestration(
                p => new MethodTaskOrchestration(ActivatorUtilities.GetServiceOrCreateInstance(p, type), methodInfo),
                name ?? NameVersionHelper.GetDefaultName(methodInfo),
                version ?? NameVersionHelper.GetDefaultVersion(methodInfo));
        }

        public static IDurableTaskWorkerBuilder AddOrchestration<T>(
            this IDurableTaskWorkerBuilder builder,
            string name = null,
            string version = null)
            where T : TaskOrchestration
        {
            return builder.AddOrchestration(typeof(T), name, version);
        }

        public static IDurableTaskWorkerBuilder AddOrchestration(
            this IDurableTaskWorkerBuilder builder,
            Type type,
            string name = null,
            string version = null)
        {
            return builder.AddOrchestration(
                p => ActivatorUtilities.GetServiceOrCreateInstance(p, type) as TaskOrchestration,
                name ?? NameVersionHelper.GetDefaultName(type),
                version ?? NameVersionHelper.GetDefaultVersion(type));
        }

        public static IDurableTaskWorkerBuilder AddAnnotatedActivitiesFrom(
            this IDurableTaskWorkerBuilder builder,
            Assembly assembly)
        {
            foreach (var type in assembly.GetTypes())
                builder.AddAnnotatedActivitiesFrom(type);
            return builder;
        }

        public static IDurableTaskWorkerBuilder AddAnnotatedActivitiesFrom(
            this IDurableTaskWorkerBuilder builder,
            Type type)
        {
            var typeActivityAttribute = type.GetCustomAttribute<ActivityAttribute>();
            if (typeActivityAttribute != null)
            {
                builder.AddActivity(type, typeActivityAttribute.Name, typeActivityAttribute.Version);
            }
            foreach (var methodInfo in type.GetMethods())
            {
                var methodActivityAttribute = methodInfo.GetCustomAttribute<ActivityAttribute>();
                if (methodActivityAttribute != null)
                {
                    builder.AddActivityMethod(type, methodInfo, methodActivityAttribute.Name, methodActivityAttribute.Version);
                }
            }
            return builder;
        }

        public static IDurableTaskWorkerBuilder AddActivitiesFromInterface<TService, TImplementation>(
            this IDurableTaskWorkerBuilder builder,
            bool useFullyQualifiedMethodNames = false)
            where TImplementation : TService
        {
            return builder.AddActivitiesFromInterface(typeof(TService), typeof(TImplementation), useFullyQualifiedMethodNames);
        }

        public static IDurableTaskWorkerBuilder AddActivitiesFromInterface(
            this IDurableTaskWorkerBuilder builder,
            Type interfaceType,
            Type implementationType,
            bool useFullyQualifiedMethodNames = false)
        {
            if (!interfaceType.IsInterface)
                throw new ArgumentException($"Type {interfaceType} is not an interface", nameof(interfaceType));

            if (!interfaceType.IsAssignableFrom(implementationType))
                throw new ArgumentException($"{implementationType.FullName} does not implement {interfaceType.FullName}", nameof(implementationType));

            foreach (var methodInfo in interfaceType.GetMethods())
            {
                var name = NameVersionHelper.GetDefaultName(methodInfo, useFullyQualifiedMethodNames);
                var version = NameVersionHelper.GetDefaultVersion(methodInfo);
                builder.AddActivityMethod(
                    implementationType,
                    methodInfo,
                    name,
                    version);
            }

            return builder;
        }

        public static IDurableTaskWorkerBuilder AddActivityMethod(
            this IDurableTaskWorkerBuilder builder,
            Type serviceType,
            MethodInfo methodInfo,
            string name = null,
            string version = null)
        {
            return builder.AddActivity(
                p => new MethodTaskActivity(ActivatorUtilities.GetServiceOrCreateInstance(p, serviceType), methodInfo),
                name ?? NameVersionHelper.GetDefaultName(methodInfo),
                version ?? NameVersionHelper.GetDefaultVersion(methodInfo));
        }

        public static IDurableTaskWorkerBuilder AddActivity<T>(
            this IDurableTaskWorkerBuilder builder,
            string name = null,
            string version = null)
            where T : TaskActivity
        {
            return builder.AddActivity(typeof(T), name, version);
        }

        public static IDurableTaskWorkerBuilder AddActivity(
            this IDurableTaskWorkerBuilder builder,
            Type type,
            string name = null,
            string version = null)
        {
            return builder.AddActivity(
                p => ActivatorUtilities.GetServiceOrCreateInstance(p, type) as TaskActivity,
                name ?? NameVersionHelper.GetDefaultName(type),
                version ?? NameVersionHelper.GetDefaultVersion(type));
        }

        public static IDurableTaskWorkerBuilder AddOrchestrationDispatcherMiddleware(
            this IDurableTaskWorkerBuilder builder,
            Func<DispatchMiddlewareContext, Func<Task>, Task> middleware)
        {
            return builder.AddOrchestrationDispatcherMiddleware(_ => middleware);
        }

        public static IDurableTaskWorkerBuilder AddActivityDispatcherMiddleware(
            this IDurableTaskWorkerBuilder builder,
            Func<DispatchMiddlewareContext, Func<Task>, Task> middleware)
        {
            return builder.AddActivityDispatcherMiddleware(_ => middleware);
        }
    }
}

1
2	using System;
3	using System.Threading.Tasks;
4	using DurableTask.Core;
5	using DurableTask.Core.Middleware;
6	using LLL.DurableTask.Worker.Orchestrations;
7	using LLL.DurableTask.Worker.Builder;
8	using System.Reflection;
9	using LLL.DurableTask.Worker.Attributes;
10
11	namespace Microsoft.Extensions.DependencyInjection
12	{
13	public static class DurableTaskWorkerBuilderExtensions
14	{
15	public static IDurableTaskWorkerBuilder AddAnnotatedFrom(
16	this IDurableTaskWorkerBuilder builder,
17	Assembly assembly)
18	{
19	return builder	×
20	.AddAnnotatedOrchestrationsFrom(assembly)	×
21	.AddAnnotatedActivitiesFrom(assembly);	×
22	}
23
24	public static IDurableTaskWorkerBuilder AddAnnotatedFrom(
25	this IDurableTaskWorkerBuilder builder,
26	Type type)
27	{
28	return builder	52✔
29	.AddAnnotatedOrchestrationsFrom(type)	52✔
30	.AddAnnotatedActivitiesFrom(type);	52✔
31	}
32
33	public static IDurableTaskWorkerBuilder AddAnnotatedOrchestrationsFrom(
34	this IDurableTaskWorkerBuilder builder,
35	Assembly assembly)
36	{
37	foreach (var type in assembly.GetTypes())	×
38	builder.AddAnnotatedOrchestrationsFrom(type);	×
39	return builder;	×
40	}
41
42	public static IDurableTaskWorkerBuilder AddAnnotatedOrchestrationsFrom(
43	this IDurableTaskWorkerBuilder builder,
44	Type type)
45	{
46	var typeOrchestrationAttribute = type.GetCustomAttribute<OrchestrationAttribute>();	52✔
47	if (typeOrchestrationAttribute != null)	52✔
48	{
49	builder.AddOrchestration(type, typeOrchestrationAttribute.Name, typeOrchestrationAttribute.Version);	24✔
50	}
51	foreach (var methodInfo in type.GetMethods())	1,188✔
52	{
53	var orchestrationAttribute = methodInfo.GetCustomAttribute<OrchestrationAttribute>();	542✔
54	if (orchestrationAttribute != null)	542✔
55	{
56	builder.AddOrchestrationMethod(type, methodInfo, orchestrationAttribute.Name, orchestrationAttribute.Version);	47✔
57	}
58	}
59	return builder;	52✔
60	}
61
62	public static IDurableTaskWorkerBuilder AddOrchestrationMethod(
63	this IDurableTaskWorkerBuilder builder,
64	Type type,
65	MethodInfo methodInfo,
66	string name = null,
67	string version = null)
68	{
69	return builder.AddOrchestration(	47✔
70	p => new MethodTaskOrchestration(ActivatorUtilities.GetServiceOrCreateInstance(p, type), methodInfo),	61✔
71	name ?? NameVersionHelper.GetDefaultName(methodInfo),	47✔
72	version ?? NameVersionHelper.GetDefaultVersion(methodInfo));	47✔
73	}
74
75	public static IDurableTaskWorkerBuilder AddOrchestration<T>(
76	this IDurableTaskWorkerBuilder builder,
77	string name = null,
78	string version = null)
79	where T : TaskOrchestration
80	{
81	return builder.AddOrchestration(typeof(T), name, version);	612✔
82	}
83
84	public static IDurableTaskWorkerBuilder AddOrchestration(
85	this IDurableTaskWorkerBuilder builder,
86	Type type,
87	string name = null,
88	string version = null)
89	{
90	return builder.AddOrchestration(	636✔
91	p => ActivatorUtilities.GetServiceOrCreateInstance(p, type) as TaskOrchestration,	791✔
92	name ?? NameVersionHelper.GetDefaultName(type),	636✔
93	version ?? NameVersionHelper.GetDefaultVersion(type));	636✔
94	}
95
96	public static IDurableTaskWorkerBuilder AddAnnotatedActivitiesFrom(
97	this IDurableTaskWorkerBuilder builder,
98	Assembly assembly)
99	{
100	foreach (var type in assembly.GetTypes())	×
101	builder.AddAnnotatedActivitiesFrom(type);	×
102	return builder;	×
103	}
104
105	public static IDurableTaskWorkerBuilder AddAnnotatedActivitiesFrom(
106	this IDurableTaskWorkerBuilder builder,
107	Type type)
108	{
109	var typeActivityAttribute = type.GetCustomAttribute<ActivityAttribute>();	52✔
110	if (typeActivityAttribute != null)	52✔
111	{
112	builder.AddActivity(type, typeActivityAttribute.Name, typeActivityAttribute.Version);	6✔
113	}
114	foreach (var methodInfo in type.GetMethods())	1,188✔
115	{
116	var methodActivityAttribute = methodInfo.GetCustomAttribute<ActivityAttribute>();	542✔
117	if (methodActivityAttribute != null)	542✔
118	{
119	builder.AddActivityMethod(type, methodInfo, methodActivityAttribute.Name, methodActivityAttribute.Version);	41✔
120	}
121	}
122	return builder;	52✔
123	}
124
125	public static IDurableTaskWorkerBuilder AddActivitiesFromInterface<TService, TImplementation>(
126	this IDurableTaskWorkerBuilder builder,
127	bool useFullyQualifiedMethodNames = false)
128	where TImplementation : TService
129	{
130	return builder.AddActivitiesFromInterface(typeof(TService), typeof(TImplementation), useFullyQualifiedMethodNames);	1✔
131	}
132
133	public static IDurableTaskWorkerBuilder AddActivitiesFromInterface(
134	this IDurableTaskWorkerBuilder builder,
135	Type interfaceType,
136	Type implementationType,
137	bool useFullyQualifiedMethodNames = false)
138	{
139	if (!interfaceType.IsInterface)	1✔
140	throw new ArgumentException($"Type {interfaceType} is not an interface", nameof(interfaceType));	×
141
142	if (!interfaceType.IsAssignableFrom(implementationType))	1✔
143	throw new ArgumentException($"{implementationType.FullName} does not implement {interfaceType.FullName}", nameof(implementationType));	×
144
145	foreach (var methodInfo in interfaceType.GetMethods())	4✔
146	{
147	var name = NameVersionHelper.GetDefaultName(methodInfo, useFullyQualifiedMethodNames);	1✔
148	var version = NameVersionHelper.GetDefaultVersion(methodInfo);	1✔
149	builder.AddActivityMethod(	1✔
150	implementationType,	1✔
151	methodInfo,	1✔
152	name,	1✔
153	version);	1✔
154	}
155
156	return builder;	1✔
157	}
158
159	public static IDurableTaskWorkerBuilder AddActivityMethod(
160	this IDurableTaskWorkerBuilder builder,
161	Type serviceType,
162	MethodInfo methodInfo,
163	string name = null,
164	string version = null)
165	{
166	return builder.AddActivity(	42✔
167	p => new MethodTaskActivity(ActivatorUtilities.GetServiceOrCreateInstance(p, serviceType), methodInfo),	52✔
168	name ?? NameVersionHelper.GetDefaultName(methodInfo),	42✔
169	version ?? NameVersionHelper.GetDefaultVersion(methodInfo));	42✔
170	}
171
172	public static IDurableTaskWorkerBuilder AddActivity<T>(
173	this IDurableTaskWorkerBuilder builder,
174	string name = null,
175	string version = null)
176	where T : TaskActivity
177	{
178	return builder.AddActivity(typeof(T), name, version);	228✔
179	}
180
181	public static IDurableTaskWorkerBuilder AddActivity(
182	this IDurableTaskWorkerBuilder builder,
183	Type type,
184	string name = null,
185	string version = null)
186	{
187	return builder.AddActivity(	234✔
188	p => ActivatorUtilities.GetServiceOrCreateInstance(p, type) as TaskActivity,	328✔
189	name ?? NameVersionHelper.GetDefaultName(type),	234✔
190	version ?? NameVersionHelper.GetDefaultVersion(type));	234✔
191	}
192
193	public static IDurableTaskWorkerBuilder AddOrchestrationDispatcherMiddleware(
194	this IDurableTaskWorkerBuilder builder,
195	Func<DispatchMiddlewareContext, Func<Task>, Task> middleware)
196	{
197	return builder.AddOrchestrationDispatcherMiddleware(_ => middleware);	×
198	}
199
200	public static IDurableTaskWorkerBuilder AddActivityDispatcherMiddleware(
201	this IDurableTaskWorkerBuilder builder,
202	Func<DispatchMiddlewareContext, Func<Task>, Task> middleware)
203	{
204	return builder.AddActivityDispatcherMiddleware(_ => middleware);	×
205	}
206	}
207	}

lucaslorentz / durabletask-extensions / 4449659504

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous