5835751495

pending completion

Build # 5835751495

Build Type

push

github

Committed by

lucaslorentz

Commit Message

Add husky and apply some code fixes

Run Details

2502 of 2502 new or added lines in 91 files covered. (100.0%)

2286 of 2792 relevant lines covered (81.88%)

143.14 hits per line

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

80.3

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

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

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

lucaslorentz / durabletask-extensions / 5835751495

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