5836038789

pending completion

Build # 5836038789

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%)

2295 of 2792 relevant lines covered (82.2%)

143.82 hits per line

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

74.58

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

﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using DurableTask.Core;
using DurableTask.Core.Middleware;
using LLL.DurableTask.Core;
using LLL.DurableTask.Worker.Activities;
using LLL.DurableTask.Worker.Middlewares;
using LLL.DurableTask.Worker.ObjectCreators;
using LLL.DurableTask.Worker.Orchestrations;
using LLL.DurableTask.Worker.Services;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;

namespace LLL.DurableTask.Worker.Builder;

public class DurableTaskWorkerBuilder : IDurableTaskWorkerBuilder
{
    private readonly List<Func<IServiceProvider, Func<DispatchMiddlewareContext, Func<Task>, Task>>> _orchestrationMiddlewares
        = new();

    private readonly List<Func<IServiceProvider, Func<DispatchMiddlewareContext, Func<Task>, Task>>> _activitiesMiddlewares
        = new();

    public IServiceCollection Services { get; }

    public DurableTaskWorkerBuilder(IServiceCollection services)
    {
        Services = services;
    }

    public DurableTaskWorkerBuilder AddOrchestration(
        Func<IServiceProvider, TaskOrchestration> factory,
        string name,
        string version)
    {
        Services.AddSingleton<ObjectCreator<TaskOrchestration>>(new FactoryObjectCreator<TaskOrchestration>(
            name,
            version,
            () => new ServiceProviderTaskOrchestration(factory)));

        return this;
    }

    public DurableTaskWorkerBuilder AddActivity(
        Func<IServiceProvider, TaskActivity> factory,
        string name,
        string version)
    {
        Services.AddSingleton<ObjectCreator<TaskActivity>>(new FactoryObjectCreator<TaskActivity>(
            name,
            version,
            () => new ServiceProviderTaskActivity(factory)));

        return this;
    }

    public DurableTaskWorkerBuilder AddOrchestrationDispatcherMiddleware(
        Func<IServiceProvider, Func<DispatchMiddlewareContext, Func<Task>, Task>> factory)
    {
        _orchestrationMiddlewares.Add(factory);
        return this;
    }

    public DurableTaskWorkerBuilder AddActivityDispatcherMiddleware(
        Func<IServiceProvider, Func<DispatchMiddlewareContext, Func<Task>, Task>> factory)
    {
        _activitiesMiddlewares.Add(factory);
        return this;
    }

    public bool HasAllOrchestrations { get; set; }
    public bool HasAllActivities { get; set; }

    internal TaskHubWorker Build(IServiceProvider provider)
    {
        var orchestrationService = provider.GetRequiredService<IOrchestrationService>();
        var distributedOrchestrationService = provider.GetService<IDistributedOrchestrationService>();
        var serviceScopeFactory = provider.GetRequiredService<IServiceScopeFactory>();

        var orchestrations = provider.GetServices<ObjectCreator<TaskOrchestration>>().ToArray();
        var activities = provider.GetServices<ObjectCreator<TaskActivity>>().ToArray();

        var serviceProviderOrchestrationService = new WorkerOrchestrationService(
            orchestrationService,
            distributedOrchestrationService,
            serviceScopeFactory,
            orchestrations,
            activities,
            HasAllOrchestrations,
            HasAllActivities);

        var loggerFactory = provider.GetService<ILoggerFactory>();

        var taskHubWorker = new TaskHubWorker(serviceProviderOrchestrationService, loggerFactory);

        // Orchestration middlewares
        var serviceProviderOrchestrationMiddleware = provider.GetRequiredService<ServiceProviderOrchestrationMiddleware>();
        taskHubWorker.AddOrchestrationDispatcherMiddleware(serviceProviderOrchestrationMiddleware.Execute);
        foreach (var middleware in _orchestrationMiddlewares)
            taskHubWorker.AddOrchestrationDispatcherMiddleware(CreateMiddleware(middleware));

        // Activitie middlewares
        var serviceProviderActivityMiddleware = provider.GetRequiredService<ServiceProviderActivityMiddleware>();
        taskHubWorker.AddActivityDispatcherMiddleware(serviceProviderActivityMiddleware.Execute);
        foreach (var factory in _activitiesMiddlewares)
            taskHubWorker.AddActivityDispatcherMiddleware(CreateMiddleware(factory));

        // Orchestrations and activities
        taskHubWorker.AddTaskOrchestrations(orchestrations);
        taskHubWorker.AddTaskActivities(activities);

        taskHubWorker.ErrorPropagationMode = ErrorPropagationMode.UseFailureDetails;

        return taskHubWorker;
    }

    private Func<DispatchMiddlewareContext, Func<Task>, Task> CreateMiddleware(
        Func<IServiceProvider, Func<DispatchMiddlewareContext, Func<Task>, Task>> middlewareFactory)
    {
        return async (context, next) =>
        {
            var serviceProvider = context.GetProperty<IServiceProvider>()
                ?? throw new Exception("No service provider in dispatchMiddlewareContext");

            var middleware = middlewareFactory(serviceProvider);

            await middleware(context, next);
        };
    }
}

1	using System;
2	using System.Collections.Generic;
3	using System.Linq;
4	using System.Threading.Tasks;
5	using DurableTask.Core;
6	using DurableTask.Core.Middleware;
7	using LLL.DurableTask.Core;
8	using LLL.DurableTask.Worker.Activities;
9	using LLL.DurableTask.Worker.Middlewares;
10	using LLL.DurableTask.Worker.ObjectCreators;
11	using LLL.DurableTask.Worker.Orchestrations;
12	using LLL.DurableTask.Worker.Services;
13	using Microsoft.Extensions.DependencyInjection;
14	using Microsoft.Extensions.Logging;
15
16	namespace LLL.DurableTask.Worker.Builder;
17
18	public class DurableTaskWorkerBuilder : IDurableTaskWorkerBuilder
19	{
20	private readonly List<Func<IServiceProvider, Func<DispatchMiddlewareContext, Func<Task>, Task>>> _orchestrationMiddlewares	114✔
21	= new();	114✔
22
23	private readonly List<Func<IServiceProvider, Func<DispatchMiddlewareContext, Func<Task>, Task>>> _activitiesMiddlewares	114✔
24	= new();	114✔
25
26	public IServiceCollection Services { get; }	960✔
27
28	public DurableTaskWorkerBuilder(IServiceCollection services)	114✔
29	{
30	Services = services;	114✔
31	}
32
33	public DurableTaskWorkerBuilder AddOrchestration(
34	Func<IServiceProvider, TaskOrchestration> factory,
35	string name,
36	string version)
37	{
38	Services.AddSingleton<ObjectCreator<TaskOrchestration>>(new FactoryObjectCreator<TaskOrchestration>(	684✔
39	name,	684✔
40	version,	684✔
41	() => new ServiceProviderTaskOrchestration(factory)));	856✔
42
43	return this;	684✔
44	}
45
46	public DurableTaskWorkerBuilder AddActivity(
47	Func<IServiceProvider, TaskActivity> factory,
48	string name,
49	string version)
50	{
51	Services.AddSingleton<ObjectCreator<TaskActivity>>(new FactoryObjectCreator<TaskActivity>(	276✔
52	name,	276✔
53	version,	276✔
54	() => new ServiceProviderTaskActivity(factory)));	380✔
55
56	return this;	276✔
57	}
58
59	public DurableTaskWorkerBuilder AddOrchestrationDispatcherMiddleware(
60	Func<IServiceProvider, Func<DispatchMiddlewareContext, Func<Task>, Task>> factory)
61	{
62	_orchestrationMiddlewares.Add(factory);	×
63	return this;	×
64	}
65
66	public DurableTaskWorkerBuilder AddActivityDispatcherMiddleware(
67	Func<IServiceProvider, Func<DispatchMiddlewareContext, Func<Task>, Task>> factory)
68	{
69	_activitiesMiddlewares.Add(factory);	×
70	return this;	×
71	}
72
73	public bool HasAllOrchestrations { get; set; }	114✔
74	public bool HasAllActivities { get; set; }	114✔
75
76	internal TaskHubWorker Build(IServiceProvider provider)
77	{
78	var orchestrationService = provider.GetRequiredService<IOrchestrationService>();	114✔
79	var distributedOrchestrationService = provider.GetService<IDistributedOrchestrationService>();	114✔
80	var serviceScopeFactory = provider.GetRequiredService<IServiceScopeFactory>();	114✔
81
82	var orchestrations = provider.GetServices<ObjectCreator<TaskOrchestration>>().ToArray();	114✔
83	var activities = provider.GetServices<ObjectCreator<TaskActivity>>().ToArray();	114✔
84
85	var serviceProviderOrchestrationService = new WorkerOrchestrationService(	114✔
86	orchestrationService,	114✔
87	distributedOrchestrationService,	114✔
88	serviceScopeFactory,	114✔
89	orchestrations,	114✔
90	activities,	114✔
91	HasAllOrchestrations,	114✔
92	HasAllActivities);	114✔
93
94	var loggerFactory = provider.GetService<ILoggerFactory>();	114✔
95
96	var taskHubWorker = new TaskHubWorker(serviceProviderOrchestrationService, loggerFactory);	114✔
97
98	// Orchestration middlewares
99	var serviceProviderOrchestrationMiddleware = provider.GetRequiredService<ServiceProviderOrchestrationMiddleware>();	114✔
100	taskHubWorker.AddOrchestrationDispatcherMiddleware(serviceProviderOrchestrationMiddleware.Execute);	114✔
101	foreach (var middleware in _orchestrationMiddlewares)	228✔
102	taskHubWorker.AddOrchestrationDispatcherMiddleware(CreateMiddleware(middleware));	×
103
104	// Activitie middlewares
105	var serviceProviderActivityMiddleware = provider.GetRequiredService<ServiceProviderActivityMiddleware>();	114✔
106	taskHubWorker.AddActivityDispatcherMiddleware(serviceProviderActivityMiddleware.Execute);	114✔
107	foreach (var factory in _activitiesMiddlewares)	228✔
108	taskHubWorker.AddActivityDispatcherMiddleware(CreateMiddleware(factory));	×
109
110	// Orchestrations and activities
111	taskHubWorker.AddTaskOrchestrations(orchestrations);	114✔
112	taskHubWorker.AddTaskActivities(activities);	114✔
113
114	taskHubWorker.ErrorPropagationMode = ErrorPropagationMode.UseFailureDetails;	114✔
115
116	return taskHubWorker;	114✔
117	}
118
119	private Func<DispatchMiddlewareContext, Func<Task>, Task> CreateMiddleware(
120	Func<IServiceProvider, Func<DispatchMiddlewareContext, Func<Task>, Task>> middlewareFactory)
121	{
122	return async (context, next) =>	×
123	{	×
124	var serviceProvider = context.GetProperty<IServiceProvider>()	×
125	?? throw new Exception("No service provider in dispatchMiddlewareContext");	×
126		×
127	var middleware = middlewareFactory(serviceProvider);	×
128		×
129	await middleware(context, next);	×
130	};	×
131	}
132	}

lucaslorentz / durabletask-extensions / 5836038789

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