5805868292

pending completion

Build # 5805868292

Build Type

push

github

Committed by

lucaslorentz

Commit Message

Search by completed time

Run Details

12 of 12 new or added lines in 5 files covered. (100.0%)

2311 of 2794 relevant lines covered (82.71%)

145.34 hits per line

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

67.74

/src/LLL.DurableTask.Worker/Activities/MethodTaskActivity.cs

﻿using System;
using System.Collections.Generic;
using System.Reflection;
using System.Runtime.ExceptionServices;
using System.Threading.Tasks;
using DurableTask.Core;
using DurableTask.Core.Serializing;
using LLL.DurableTask.Core.Serializing;
using Newtonsoft.Json.Linq;

namespace LLL.DurableTask.Worker.Orchestrations
{
    public class MethodTaskActivity : TaskActivity
    {
        private readonly MethodInfo _methodInfo;
        private readonly DataConverter _dataConverter;

        public MethodTaskActivity(
            object instance,
            MethodInfo methodInfo)
        {
            Instance = instance;
            _methodInfo = methodInfo;
            _dataConverter = new TypelessJsonDataConverter();
        }

        public object Instance { get; }

        public override string Run(TaskContext context, string input)
        {
            throw new NotImplementedException();
        }

        public override async Task<string> RunAsync(TaskContext context, string input)
        {
            var parameters = PrepareParameters(input, new Dictionary<Type, Func<object>>
            {
                [typeof(TaskContext)] = () => context
            });

            try
            {
                var result = _methodInfo.Invoke(Instance, parameters);
                return await SerializeResult(result);
            }
            catch (TargetInvocationException ex)
            {
                ExceptionDispatchInfo.Capture(ex.InnerException).Throw();
                throw;
            }
        }

        private object[] PrepareParameters(
            string input,
            Dictionary<Type, Func<object>> factories)
        {
            var jsonParameters = _dataConverter.Deserialize<JToken[]>(input);

            var inputPosition = 0;

            var parameters = new List<object>();

            foreach (var parameter in _methodInfo.GetParameters())
            {
                object value;

                if (factories.TryGetValue(parameter.ParameterType, out var factory))
                {
                    value = factory();
                }
                else if (inputPosition < jsonParameters.Length)
                {
                    value = jsonParameters[inputPosition++].ToObject(parameter.ParameterType);
                }
                else if (parameter.IsOptional)
                {
                    value = parameter.DefaultValue;
                }
                else
                    throw new Exception($"Activity expects at least {inputPosition + 1} parameters but {jsonParameters.Length} were provided.");

                parameters.Add(value);
            }

            return parameters.ToArray();
        }

        private async Task<string> SerializeResult(object result)
        {
            if (result is Task task)
            {
                if (_methodInfo.ReturnType.IsGenericType)
                {
                    result = await (dynamic)task;
                }
                else
                {
                    await task;
                    result = null;
                }
            }

            var serializedResult = _dataConverter.Serialize(result);

            return serializedResult;
        }
    }
}

1	using System;
2	using System.Collections.Generic;
3	using System.Reflection;
4	using System.Runtime.ExceptionServices;
5	using System.Threading.Tasks;
6	using DurableTask.Core;
7	using DurableTask.Core.Serializing;
8	using LLL.DurableTask.Core.Serializing;
9	using Newtonsoft.Json.Linq;
10
11	namespace LLL.DurableTask.Worker.Orchestrations
12	{
13	public class MethodTaskActivity : TaskActivity
14	{
15	private readonly MethodInfo _methodInfo;
16	private readonly DataConverter _dataConverter;
17
18	public MethodTaskActivity(	11✔
19	object instance,	11✔
20	MethodInfo methodInfo)	11✔
21	{
22	Instance = instance;	11✔
23	_methodInfo = methodInfo;	11✔
24	_dataConverter = new TypelessJsonDataConverter();	11✔
25	}
26
27	public object Instance { get; }	11✔
28
29	public override string Run(TaskContext context, string input)
30	{
31	throw new NotImplementedException();	×
32	}
33
34	public override async Task<string> RunAsync(TaskContext context, string input)
35	{
36	var parameters = PrepareParameters(input, new Dictionary<Type, Func<object>>	11✔
37	{	11✔
38	[typeof(TaskContext)] = () => context	11✔
39	});	11✔
40
41	try
42	{
43	var result = _methodInfo.Invoke(Instance, parameters);	11✔
44	return await SerializeResult(result);	10✔
45	}
46	catch (TargetInvocationException ex)
47	{
48	ExceptionDispatchInfo.Capture(ex.InnerException).Throw();	1✔
49	throw;	×
50	}
51	}
52
53	private object[] PrepareParameters(
54	string input,
55	Dictionary<Type, Func<object>> factories)
56	{
57	var jsonParameters = _dataConverter.Deserialize<JToken[]>(input);	11✔
58
59	var inputPosition = 0;	11✔
60
61	var parameters = new List<object>();	11✔
62
63	foreach (var parameter in _methodInfo.GetParameters())	22✔
64	{
65	object value;
66
67	if (factories.TryGetValue(parameter.ParameterType, out var factory))	×
68	{
69	value = factory();	×
70	}
71	else if (inputPosition < jsonParameters.Length)	×
72	{
73	value = jsonParameters[inputPosition++].ToObject(parameter.ParameterType);	×
74	}
75	else if (parameter.IsOptional)	×
76	{
77	value = parameter.DefaultValue;	×
78	}
79	else
80	throw new Exception($"Activity expects at least {inputPosition + 1} parameters but {jsonParameters.Length} were provided.");	×
81
82	parameters.Add(value);	×
83	}
84
85	return parameters.ToArray();	11✔
86	}
87
88	private async Task<string> SerializeResult(object result)
89	{
90	if (result is Task task)	10✔
91	{
92	if (_methodInfo.ReturnType.IsGenericType)	7✔
93	{
94	result = await (dynamic)task;
95	}
96	else
97	{
98	await task;
99	result = null;
100	}
101	}
102
103	var serializedResult = _dataConverter.Serialize(result);
104
105	return serializedResult;
106	}
107	}
108	}

lucaslorentz / durabletask-extensions / 5805868292

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