StudyGroup
/
Polly8Study
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

更新

Browse Source
main
bicijinlian 9 months ago
parent ce5c75a236
commit 625561e22c
5 changed files with 101 additions and 93 deletions
Show Stats Download Patch File Download Diff File

12
Polly8Study.Test/Polly8RetryStrategyTest.cs
Unescape Escape View File

@ -1,10 +1,10 @@
namespace Polly8Study.Test
namespace Polly8Study.Test
{
/// <summary>
/// Polly8超时策略 测试
/// 关键：
/// CancellationToken，没有这个是不起使用的
/// 就是之前版本中的乐观超时，悲观超时貌似取消了
/// Polly8超时策略 测试
/// 关键：
/// CancellationToken，没有这个是不起使用的
/// 就是之前版本中的乐观超时，悲观超时貌似取消了
/// </summary>
public class Polly8RetryStrategyTest
{
@ -16,7 +16,7 @@ namespace Polly8Study.Test
}
/// <summary>
/// 重试策略
/// 重试策略
/// </summary>
[Fact]
public void Test()

170
Polly8Study.Test/Polly8TimeoutStrategyTest.cs
Unescape Escape View File

@ -1,10 +1,10 @@
namespace Polly8Study.Test
namespace Polly8Study.Test
{
/// <summary>
/// Polly8超时策略 测试
/// 关键：
/// V8不支持悲观超时
/// 只支持乐观超时：使用内部和外部CancellationToken
/// Polly8超时策略 测试
/// 关键：
/// V8不支持悲观超时
/// 只支持乐观超时：使用内部和外部CancellationToken
/// </summary>
public class Polly8TimeoutStrategyTest
{
@ -16,29 +16,29 @@ namespace Polly8Study.Test
}
/// <summary>
/// 超时策略选项
/// 超时策略选项
/// </summary>
[Fact]
public void TimeoutStrategyOptions_Test()
{
//直接设置
//直接设置
new ResiliencePipelineBuilder()
.AddTimeout(TimeSpan.FromMilliseconds(100))
.Build();
//默认值
//默认值
var defaultOption = new TimeoutStrategyOptions();
//全功能
//全功能
TimeoutStrategyOptions timeoutOption = new TimeoutStrategyOptions
{
//名称唯一标识了特定策略的特定实例，也包含在由各个弹性策略生成的遥测数据中
//名称唯一标识了特定策略的特定实例，也包含在由各个弹性策略生成的遥测数据中
Name = "timeout",
//固定超时时间(启用了TimeoutGenerator，则无效)
//固定超时时间(启用了TimeoutGenerator，则无效)
Timeout = TimeSpan.FromSeconds(2),
//动态超时时间设置
//动态超时时间设置
//TimeoutGenerator = arg =>
//{
// var ts = TimeSpan.FromSeconds(Math.Pow(2, 1));
@ -46,7 +46,7 @@ namespace Polly8Study.Test
// return ValueTask.FromResult(ts);
//},
//发生超时时引发的超时委托
//发生超时时引发的超时委托
OnTimeout = (args) =>
{
var key = args.Context.OperationKey;
@ -55,15 +55,17 @@ namespace Polly8Study.Test
},
};
//使用
//使用
ResiliencePipeline pipeline = new ResiliencePipelineBuilder()
.AddTimeout(timeoutOption)
.Build();
Assert.NotEmpty(pipeline.AsSyncPolicy().PolicyKey);
}
/// <summary>
/// 非可取消任务：忽略超时
/// 同步执行
/// 非可取消任务：忽略超时
/// 同步执行
/// </summary>
[Fact]
public void No_CancellationToken_Test()
@ -72,24 +74,24 @@ namespace Polly8Study.Test
.AddTimeout(TimeSpan.FromSeconds(1))
.Build();
//外部tcs可省略
//外部tcs可省略
var tcs = new CancellationTokenSource();
try
{
pipeline.Execute
(
//此处必须是可取消的任务，否则超时不作为(一直等待)
//此处必须是可取消的任务，否则超时不作为(一直等待)
callback: (CancellationToken innerToken) =>
{
//虽然接口耗时大，因为没有使用‘可取消的’ Send请求，超时设置被忽略，会等待接口正确返回
//虽然接口耗时大，因为没有使用‘可取消的’ Send请求，超时设置被忽略，会等待接口正确返回
HttpRequestMessage requestMessage = new HttpRequestMessage(HttpMethod.Get, "http://localhost:44344/api/Timeout/Slow");
//关键：Send方法 没有传入参数 cancellationToken
//其它同步方法，只要是可取消方法均可
//关键：Send方法 没有传入参数 cancellationToken
//其它同步方法，只要是可取消方法均可
HttpResponseMessage response = new HttpClient().Send(requestMessage);
if (response.IsSuccessStatusCode == false)
{
_output.WriteLine($"非正常响应,响应码：{response.StatusCode}");
_output.WriteLine($"非正常响应,响应码：{response.StatusCode}");
return;
}
var stream = response.Content.ReadAsStream();
@ -98,24 +100,24 @@ namespace Polly8Study.Test
var text = System.Text.UTF8Encoding.UTF8.GetString(bs);
_output.WriteLine($"响应内容:{text}");
_output.WriteLine($"响应内容:{text}");
_output.WriteLine("任务执行完成");
_output.WriteLine("任务执行完成");
},
cancellationToken: tcs.Token
);
}
catch (OperationCanceledException ex)
{
_output.WriteLine($"任务取消，引发异常:{ex.Message}");
_output.WriteLine($"任务取消，引发异常:{ex.Message}");
}
catch (TimeoutRejectedException ex)
{
_output.WriteLine($"超时，引发异常:{ex.Message}");
_output.WriteLine($"超时，引发异常:{ex.Message}");
}
catch (Exception ex)
{
_output.WriteLine($"API服务异常：{ex.Message}");
_output.WriteLine($"API服务异常：{ex.Message}");
}
finally
{
@ -124,21 +126,21 @@ namespace Polly8Study.Test
}
/// <summary>
/// 可取消任务:超时
/// 同步执行
/// 可取消任务:超时
/// 同步执行
/// </summary>
[Fact]
public void Has_CancellationToken_Timeout_Test()
{
TimeoutStrategyOptions timeoutOption = new TimeoutStrategyOptions
{
//名称唯一标识了特定策略的特定实例，也包含在由各个弹性策略生成的遥测数据中
//名称唯一标识了特定策略的特定实例，也包含在由各个弹性策略生成的遥测数据中
Name = "timeout",
//固定超时时间(启用了TimeoutGenerator，则无效)
//固定超时时间(启用了TimeoutGenerator，则无效)
Timeout = TimeSpan.FromSeconds(1),
//动态超时时间设置
//动态超时时间设置
//TimeoutGenerator = arg =>
//{
// var ts = TimeSpan.FromSeconds(Math.Pow(2, 1));
@ -146,10 +148,10 @@ namespace Polly8Study.Test
// return ValueTask.FromResult(ts);
//},
//发生超时时引发的超时委托
//发生超时时引发的超时委托
OnTimeout = (args) =>
{
_output.WriteLine("OnTimeout 超时委托执行");
_output.WriteLine("OnTimeout 超时委托执行");
return ValueTask.CompletedTask;
},
};
@ -163,14 +165,14 @@ namespace Polly8Study.Test
{
pipeline.Execute
(
//此处必须是可取消的任务，否则超时不作为(一直等待)
//此处必须是可取消的任务，否则超时不作为(一直等待)
callback: (innerToken) =>
{
HttpRequestMessage r = new HttpRequestMessage(HttpMethod.Get, "http://localhost:44344/api/Timeout/Slow");
var response = new HttpClient().Send(r, innerToken);
if (response.IsSuccessStatusCode == false)
{
Console.WriteLine("非正常响应");
Console.WriteLine("非正常响应");
return;
}
var stream = response.Content.ReadAsStream();
@ -179,23 +181,23 @@ namespace Polly8Study.Test
var text = System.Text.UTF8Encoding.UTF8.GetString(bs);
_output.WriteLine($"响应内容:{text}");
_output.WriteLine("任务执行完成");
_output.WriteLine($"响应内容:{text}");
_output.WriteLine("任务执行完成");
},
cancellationToken: tcs.Token
);
}
catch (OperationCanceledException ex)
{
_output.WriteLine($"任务取消，引发异常:{ex.Message}");
_output.WriteLine($"任务取消，引发异常:{ex.Message}");
}
catch (TimeoutRejectedException ex)
{
_output.WriteLine($"超时，引发异常:{ex.Message}");
_output.WriteLine($"超时，引发异常:{ex.Message}");
}
catch (Exception ex)
{
_output.WriteLine($"API服务异常：{ex.Message}");
_output.WriteLine($"API服务异常：{ex.Message}");
}
finally
{
@ -204,21 +206,21 @@ namespace Polly8Study.Test
}
/// <summary>
/// 可取消任务:不超时
/// 同步执行
/// 可取消任务:不超时
/// 同步执行
/// </summary>
[Fact]
public void Has_CancellationToken_NotTimeout_Test()
{
TimeoutStrategyOptions timeoutOption = new TimeoutStrategyOptions
{
//名称唯一标识了特定策略的特定实例，也包含在由各个弹性策略生成的遥测数据中
//名称唯一标识了特定策略的特定实例，也包含在由各个弹性策略生成的遥测数据中
Name = "timeout",
//固定超时时间(启用了TimeoutGenerator，则无效)
//固定超时时间(启用了TimeoutGenerator，则无效)
Timeout = TimeSpan.FromSeconds(5),
//动态超时时间设置
//动态超时时间设置
//TimeoutGenerator = arg =>
//{
// var ts = TimeSpan.FromSeconds(Math.Pow(2, 1));
@ -226,10 +228,10 @@ namespace Polly8Study.Test
// return ValueTask.FromResult(ts);
//},
//发生超时时引发的超时委托
//发生超时时引发的超时委托
OnTimeout = (args) =>
{
Console.WriteLine("OnTimeout 超时委托执行");
Console.WriteLine("OnTimeout 超时委托执行");
return ValueTask.CompletedTask;
},
};
@ -243,14 +245,14 @@ namespace Polly8Study.Test
{
pipeline.Execute
(
//此处必须是可取消的任务，否则超时不作为(一直等待)
//此处必须是可取消的任务，否则超时不作为(一直等待)
callback: (innerToken) =>
{
HttpRequestMessage r = new HttpRequestMessage(HttpMethod.Get, "http://localhost:44344/api/Timeout/Slow");
var response = new HttpClient().Send(r, innerToken);
if (response.IsSuccessStatusCode == false)
{
Console.WriteLine("非正常响应");
Console.WriteLine("非正常响应");
return;
}
var stream = response.Content.ReadAsStream();
@ -259,23 +261,23 @@ namespace Polly8Study.Test
var text = System.Text.UTF8Encoding.UTF8.GetString(bs);
_output.WriteLine($"响应内容:{text}");
_output.WriteLine("任务执行完成");
_output.WriteLine($"响应内容:{text}");
_output.WriteLine("任务执行完成");
},
cancellationToken: tcs.Token
);
}
catch (OperationCanceledException ex)
{
_output.WriteLine($"任务取消，引发异常:{ex.Message}");
_output.WriteLine($"任务取消，引发异常:{ex.Message}");
}
catch (TimeoutRejectedException ex)
{
_output.WriteLine($"超时，引发异常:{ex.Message}");
_output.WriteLine($"超时，引发异常:{ex.Message}");
}
catch (Exception ex)
{
_output.WriteLine($"API服务异常：{ex.Message}");
_output.WriteLine($"API服务异常：{ex.Message}");
}
finally
{
@ -285,25 +287,25 @@ namespace Polly8Study.Test
}
/// <summary>
/// 不可取消任务:忽略超时
/// 异步执行
/// 不可取消任务:忽略超时
/// 异步执行
/// </summary>
[Fact]
public async void No_CancellationToken_ExecuteAsync_Test()
{
TimeoutStrategyOptions timeoutOption = new TimeoutStrategyOptions
{
//名称唯一标识了特定策略的特定实例，也包含在由各个弹性策略生成的遥测数据中
//名称唯一标识了特定策略的特定实例，也包含在由各个弹性策略生成的遥测数据中
Name = "timeout",
//固定超时时间(启用了TimeoutGenerator，则无效)
//固定超时时间(启用了TimeoutGenerator，则无效)
Timeout = TimeSpan.FromSeconds(1),
//发生超时时引发的超时委托
//发生超时时引发的超时委托
OnTimeout = (args) =>
{
_output.WriteLine("OnTimeout 超时委托执行");
_output.WriteLine("OnTimeout 超时委托执行");
return ValueTask.CompletedTask;
},
};
@ -317,27 +319,27 @@ namespace Polly8Study.Test
{
await pipeline.ExecuteAsync
(
//此处为不可取消的任务，忽略超时(会一直等待)
//此处为不可取消的任务，忽略超时(会一直等待)
callback: async (innerToken) =>
{
//完成大约是2秒多，而不是超时的1秒多
//完成大约是2秒多，而不是超时的1秒多
await Task.Delay (1000*3);
_output.WriteLine("任务执行完成");
_output.WriteLine("任务执行完成");
},
cancellationToken: tcs.Token
);
}
catch (OperationCanceledException ex)
{
_output.WriteLine($"任务取消，引发异常:{ex.Message}");
_output.WriteLine($"任务取消，引发异常:{ex.Message}");
}
catch (TimeoutRejectedException ex)
{
_output.WriteLine($"超时，引发异常:{ex.Message}");
_output.WriteLine($"超时，引发异常:{ex.Message}");
}
catch (Exception ex)
{
_output.WriteLine($"API服务异常：{ex.Message}");
_output.WriteLine($"API服务异常：{ex.Message}");
}
finally
{
@ -346,8 +348,8 @@ namespace Polly8Study.Test
}
/// <summary>
/// 可取消任务:超时
/// 异步执行
/// 可取消任务:超时
/// 异步执行
/// </summary>
/// <returns></returns>
[Fact]
@ -364,9 +366,9 @@ namespace Polly8Study.Test
(
callback: async (innerToken) =>
{
//完成大约是超时的1秒多，而不是任务的3秒多
//完成大约是超时的1秒多，而不是任务的3秒多
await Task.Delay(1000 * 3, innerToken);
_output.WriteLine("任务执行完成");
_output.WriteLine("任务执行完成");
},
cancellationToken: cts.Token
);
@ -374,8 +376,8 @@ namespace Polly8Study.Test
}
/// <summary>
/// 可取消任务:不超时
/// 异步执行
/// 可取消任务:不超时
/// 异步执行
/// </summary>
/// <returns></returns>
[Fact]
@ -392,9 +394,9 @@ namespace Polly8Study.Test
(
callback: async (innerToken) =>
{
//不超时，完成大约是任务耗时的1秒
//不超时，完成大约是任务耗时的1秒
await Task.Delay(1000, innerToken);
_output.WriteLine("任务执行完成");
_output.WriteLine("任务执行完成");
},
cancellationToken: cts.Token
);
@ -406,8 +408,8 @@ namespace Polly8Study.Test
}
// <summary>
/// 可取消任务:超时
/// 异步执行，无外层Token
/// 可取消任务:超时
/// 异步执行，无外层Token
/// </summary>
/// <returns></returns>
[Fact]
@ -424,9 +426,9 @@ namespace Polly8Study.Test
(
callback: async (innerToken) =>
{
//完成大约是超时的1秒多，而不是任务的3秒多
//完成大约是超时的1秒多，而不是任务的3秒多
await Task.Delay(1000 * 3, innerToken);
_output.WriteLine("任务执行完成");
_output.WriteLine("任务执行完成");
}
);
});
@ -445,22 +447,22 @@ namespace Polly8Study.Test
{
pipeline.Execute
(
//此处必须是可取消的任务，否则超时不作为(一直等待)
//此处必须是可取消的任务，否则超时不作为(一直等待)
callback: SyncWithCancellationToken,
cancellationToken: tcs.Token
);
}
catch (OperationCanceledException ex)
{
_output.WriteLine($"任务取消，引发异常:{ex.Message}");
_output.WriteLine($"任务取消，引发异常:{ex.Message}");
}
catch (TimeoutRejectedException ex)
{
_output.WriteLine($"超时，引发异常:{ex.Message}");
_output.WriteLine($"超时，引发异常:{ex.Message}");
}
catch (Exception ex)
{
_output.WriteLine($"API服务异常：{ex.Message}");
_output.WriteLine($"API服务异常：{ex.Message}");
}
finally
{
@ -469,7 +471,7 @@ namespace Polly8Study.Test
}
/// <summary>
/// 使用CancellationToken的同步方法
/// 使用CancellationToken的同步方法
/// </summary>
private void SyncWithCancellationToken(CancellationToken cancellationToken)
{

4
Polly8Study.Test/UseXunit.cs
Unescape Escape View File

@ -1,4 +1,4 @@
namespace Polly8Study.Test
namespace Polly8Study.Test
{
public class UseXunit
{
@ -12,7 +12,7 @@ namespace Polly8Study.Test
[Fact]
public void Use_xUnit_Test()
{
var msg = "使用 xUnit 单元测试框架！";
var msg = "使用 xUnit 单元测试框架！";
Assert.True(true, msg);
_output.WriteLine(msg);

2
Polly8Study.WebApi/Program.cs
Unescape Escape View File

@ -1,4 +1,4 @@

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Filters;

6
Polly8Study.lutconfig
Unescape Escape View File

@ -0,0 +1,6 @@
<LUTConfig Version="1.0">
<Repository />
<ParallelBuilds>true</ParallelBuilds>
<ParallelTestRuns>true</ParallelTestRuns>
<TestCaseTimeout>180000</TestCaseTimeout>
</LUTConfig>
Write Preview
Loading…
Cancel
Save