You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
514 lines
20 KiB
C#
514 lines
20 KiB
C#
namespace Ocelot.IntegrationTests
|
|
{
|
|
using Administration;
|
|
using Configuration.File;
|
|
using DependencyInjection;
|
|
using Microsoft.AspNetCore.Hosting;
|
|
using Microsoft.Data.Sqlite;
|
|
using Microsoft.Extensions.Configuration;
|
|
using Microsoft.Extensions.DependencyInjection;
|
|
using Middleware;
|
|
using Newtonsoft.Json;
|
|
using Ocelot.Provider.Rafty;
|
|
using Rafty.Infrastructure;
|
|
using Shouldly;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Net.Http;
|
|
using System.Net.Http.Headers;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using Xunit;
|
|
using Xunit.Abstractions;
|
|
using Wait = Rafty.Infrastructure.Wait;
|
|
|
|
public class RaftTests : IDisposable
|
|
{
|
|
private readonly List<IWebHost> _builders;
|
|
private readonly List<IWebHostBuilder> _webHostBuilders;
|
|
private readonly List<Thread> _threads;
|
|
private FilePeers _peers;
|
|
private HttpClient _httpClient;
|
|
private readonly HttpClient _httpClientForAssertions;
|
|
private BearerToken _token;
|
|
private HttpResponseMessage _response;
|
|
private static readonly object _lock = new object();
|
|
private ITestOutputHelper _output;
|
|
|
|
public RaftTests(ITestOutputHelper output)
|
|
{
|
|
_output = output;
|
|
_httpClientForAssertions = new HttpClient();
|
|
_webHostBuilders = new List<IWebHostBuilder>();
|
|
_builders = new List<IWebHost>();
|
|
_threads = new List<Thread>();
|
|
}
|
|
|
|
[Fact(Skip = "Still not stable, more work required in rafty..")]
|
|
public async Task should_persist_command_to_five_servers()
|
|
{
|
|
var peers = new List<FilePeer>
|
|
{
|
|
new FilePeer {HostAndPort = "http://localhost:5000"},
|
|
|
|
new FilePeer {HostAndPort = "http://localhost:5001"},
|
|
|
|
new FilePeer {HostAndPort = "http://localhost:5002"},
|
|
|
|
new FilePeer {HostAndPort = "http://localhost:5003"},
|
|
|
|
new FilePeer {HostAndPort = "http://localhost:5004"}
|
|
};
|
|
|
|
var configuration = new FileConfiguration
|
|
{
|
|
GlobalConfiguration = new FileGlobalConfiguration
|
|
{
|
|
}
|
|
};
|
|
|
|
var updatedConfiguration = new FileConfiguration
|
|
{
|
|
GlobalConfiguration = new FileGlobalConfiguration
|
|
{
|
|
},
|
|
ReRoutes = new List<FileReRoute>()
|
|
{
|
|
new FileReRoute()
|
|
{
|
|
DownstreamHostAndPorts = new List<FileHostAndPort>
|
|
{
|
|
new FileHostAndPort
|
|
{
|
|
Host = "127.0.0.1",
|
|
Port = 80,
|
|
}
|
|
},
|
|
DownstreamScheme = "http",
|
|
DownstreamPathTemplate = "/geoffrey",
|
|
UpstreamHttpMethod = new List<string> { "get" },
|
|
UpstreamPathTemplate = "/"
|
|
},
|
|
new FileReRoute()
|
|
{
|
|
DownstreamHostAndPorts = new List<FileHostAndPort>
|
|
{
|
|
new FileHostAndPort
|
|
{
|
|
Host = "123.123.123",
|
|
Port = 443,
|
|
}
|
|
},
|
|
DownstreamScheme = "https",
|
|
DownstreamPathTemplate = "/blooper/{productId}",
|
|
UpstreamHttpMethod = new List<string> { "post" },
|
|
UpstreamPathTemplate = "/test"
|
|
}
|
|
}
|
|
};
|
|
|
|
var command = new UpdateFileConfiguration(updatedConfiguration);
|
|
GivenThePeersAre(peers);
|
|
GivenThereIsAConfiguration(configuration);
|
|
GivenFiveServersAreRunning();
|
|
await GivenIHaveAnOcelotToken("/administration");
|
|
await WhenISendACommandIntoTheCluster(command);
|
|
Thread.Sleep(5000);
|
|
await ThenTheCommandIsReplicatedToAllStateMachines(command);
|
|
}
|
|
|
|
[Fact(Skip = "Still not stable, more work required in rafty..")]
|
|
public async Task should_persist_command_to_five_servers_when_using_administration_api()
|
|
{
|
|
var peers = new List<FilePeer>
|
|
{
|
|
new FilePeer {HostAndPort = "http://localhost:5005"},
|
|
|
|
new FilePeer {HostAndPort = "http://localhost:5006"},
|
|
|
|
new FilePeer {HostAndPort = "http://localhost:5007"},
|
|
|
|
new FilePeer {HostAndPort = "http://localhost:5008"},
|
|
|
|
new FilePeer {HostAndPort = "http://localhost:5009"}
|
|
};
|
|
|
|
var configuration = new FileConfiguration
|
|
{
|
|
};
|
|
|
|
var updatedConfiguration = new FileConfiguration
|
|
{
|
|
ReRoutes = new List<FileReRoute>()
|
|
{
|
|
new FileReRoute()
|
|
{
|
|
DownstreamHostAndPorts = new List<FileHostAndPort>
|
|
{
|
|
new FileHostAndPort
|
|
{
|
|
Host = "127.0.0.1",
|
|
Port = 80,
|
|
}
|
|
},
|
|
DownstreamScheme = "http",
|
|
DownstreamPathTemplate = "/geoffrey",
|
|
UpstreamHttpMethod = new List<string> { "get" },
|
|
UpstreamPathTemplate = "/"
|
|
},
|
|
new FileReRoute()
|
|
{
|
|
DownstreamHostAndPorts = new List<FileHostAndPort>
|
|
{
|
|
new FileHostAndPort
|
|
{
|
|
Host = "123.123.123",
|
|
Port = 443,
|
|
}
|
|
},
|
|
DownstreamScheme = "https",
|
|
DownstreamPathTemplate = "/blooper/{productId}",
|
|
UpstreamHttpMethod = new List<string> { "post" },
|
|
UpstreamPathTemplate = "/test"
|
|
}
|
|
}
|
|
};
|
|
|
|
var command = new UpdateFileConfiguration(updatedConfiguration);
|
|
GivenThePeersAre(peers);
|
|
GivenThereIsAConfiguration(configuration);
|
|
GivenFiveServersAreRunning();
|
|
await GivenIHaveAnOcelotToken("/administration");
|
|
GivenIHaveAddedATokenToMyRequest();
|
|
await WhenIPostOnTheApiGateway("/administration/configuration", updatedConfiguration);
|
|
await ThenTheCommandIsReplicatedToAllStateMachines(command);
|
|
}
|
|
|
|
private void GivenThePeersAre(List<FilePeer> peers)
|
|
{
|
|
FilePeers filePeers = new FilePeers();
|
|
filePeers.Peers.AddRange(peers);
|
|
var json = JsonConvert.SerializeObject(filePeers);
|
|
File.WriteAllText("peers.json", json);
|
|
_httpClient = new HttpClient();
|
|
var ocelotBaseUrl = peers[0].HostAndPort;
|
|
_httpClient.BaseAddress = new Uri(ocelotBaseUrl);
|
|
}
|
|
|
|
private async Task WhenISendACommandIntoTheCluster(UpdateFileConfiguration command)
|
|
{
|
|
async Task<bool> SendCommand()
|
|
{
|
|
try
|
|
{
|
|
var p = _peers.Peers.First();
|
|
var json = JsonConvert.SerializeObject(command, new JsonSerializerSettings()
|
|
{
|
|
TypeNameHandling = TypeNameHandling.All
|
|
});
|
|
var httpContent = new StringContent(json);
|
|
httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
|
|
using (var httpClient = new HttpClient())
|
|
{
|
|
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", _token.AccessToken);
|
|
var response = await httpClient.PostAsync($"{p.HostAndPort}/administration/raft/command", httpContent);
|
|
response.EnsureSuccessStatusCode();
|
|
var content = await response.Content.ReadAsStringAsync();
|
|
|
|
var errorResult = JsonConvert.DeserializeObject<ErrorResponse<UpdateFileConfiguration>>(content);
|
|
|
|
if (!string.IsNullOrEmpty(errorResult.Error))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
var okResult = JsonConvert.DeserializeObject<OkResponse<UpdateFileConfiguration>>(content);
|
|
|
|
if (okResult.Command.Configuration.ReRoutes.Count == 2)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Console.WriteLine(e);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
var commandSent = await Wait.WaitFor(40000).Until(async () =>
|
|
{
|
|
var result = await SendCommand();
|
|
Thread.Sleep(1000);
|
|
return result;
|
|
});
|
|
|
|
commandSent.ShouldBeTrue();
|
|
}
|
|
|
|
private async Task ThenTheCommandIsReplicatedToAllStateMachines(UpdateFileConfiguration expecteds)
|
|
{
|
|
async Task<bool> CommandCalledOnAllStateMachines()
|
|
{
|
|
try
|
|
{
|
|
var passed = 0;
|
|
foreach (var peer in _peers.Peers)
|
|
{
|
|
var path = $"{peer.HostAndPort.Replace("/", "").Replace(":", "")}.db";
|
|
using (var connection = new SqliteConnection($"Data Source={path};"))
|
|
{
|
|
connection.Open();
|
|
var sql = @"select count(id) from logs";
|
|
using (var command = new SqliteCommand(sql, connection))
|
|
{
|
|
var index = Convert.ToInt32(command.ExecuteScalar());
|
|
index.ShouldBe(1);
|
|
}
|
|
}
|
|
|
|
_httpClientForAssertions.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", _token.AccessToken);
|
|
var result = await _httpClientForAssertions.GetAsync($"{peer.HostAndPort}/administration/configuration");
|
|
var json = await result.Content.ReadAsStringAsync();
|
|
var response = JsonConvert.DeserializeObject<FileConfiguration>(json, new JsonSerializerSettings { TypeNameHandling = TypeNameHandling.All });
|
|
response.GlobalConfiguration.RequestIdKey.ShouldBe(expecteds.Configuration.GlobalConfiguration.RequestIdKey);
|
|
response.GlobalConfiguration.ServiceDiscoveryProvider.Host.ShouldBe(expecteds.Configuration.GlobalConfiguration.ServiceDiscoveryProvider.Host);
|
|
response.GlobalConfiguration.ServiceDiscoveryProvider.Port.ShouldBe(expecteds.Configuration.GlobalConfiguration.ServiceDiscoveryProvider.Port);
|
|
|
|
for (var i = 0; i < response.ReRoutes.Count; i++)
|
|
{
|
|
for (var j = 0; j < response.ReRoutes[i].DownstreamHostAndPorts.Count; j++)
|
|
{
|
|
var res = response.ReRoutes[i].DownstreamHostAndPorts[j];
|
|
var expected = expecteds.Configuration.ReRoutes[i].DownstreamHostAndPorts[j];
|
|
res.Host.ShouldBe(expected.Host);
|
|
res.Port.ShouldBe(expected.Port);
|
|
}
|
|
|
|
response.ReRoutes[i].DownstreamPathTemplate.ShouldBe(expecteds.Configuration.ReRoutes[i].DownstreamPathTemplate);
|
|
response.ReRoutes[i].DownstreamScheme.ShouldBe(expecteds.Configuration.ReRoutes[i].DownstreamScheme);
|
|
response.ReRoutes[i].UpstreamPathTemplate.ShouldBe(expecteds.Configuration.ReRoutes[i].UpstreamPathTemplate);
|
|
response.ReRoutes[i].UpstreamHttpMethod.ShouldBe(expecteds.Configuration.ReRoutes[i].UpstreamHttpMethod);
|
|
}
|
|
|
|
passed++;
|
|
}
|
|
|
|
return passed == 5;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
//_output.WriteLine($"{e.Message}, {e.StackTrace}");
|
|
Console.WriteLine(e);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
var commandOnAllStateMachines = await Wait.WaitFor(40000).Until(async () =>
|
|
{
|
|
var result = await CommandCalledOnAllStateMachines();
|
|
Thread.Sleep(1000);
|
|
return result;
|
|
});
|
|
|
|
commandOnAllStateMachines.ShouldBeTrue();
|
|
}
|
|
|
|
private async Task WhenIPostOnTheApiGateway(string url, FileConfiguration updatedConfiguration)
|
|
{
|
|
async Task<bool> SendCommand()
|
|
{
|
|
var json = JsonConvert.SerializeObject(updatedConfiguration);
|
|
|
|
var content = new StringContent(json);
|
|
|
|
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
|
|
|
|
_response = await _httpClient.PostAsync(url, content);
|
|
|
|
var responseContent = await _response.Content.ReadAsStringAsync();
|
|
|
|
if (responseContent == "There was a problem. This error message sucks raise an issue in GitHub.")
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (string.IsNullOrEmpty(responseContent))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return _response.IsSuccessStatusCode;
|
|
}
|
|
|
|
var commandSent = await Wait.WaitFor(40000).Until(async () =>
|
|
{
|
|
var result = await SendCommand();
|
|
Thread.Sleep(1000);
|
|
return result;
|
|
});
|
|
|
|
commandSent.ShouldBeTrue();
|
|
}
|
|
|
|
private void GivenIHaveAddedATokenToMyRequest()
|
|
{
|
|
_httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", _token.AccessToken);
|
|
}
|
|
|
|
private async Task GivenIHaveAnOcelotToken(string adminPath)
|
|
{
|
|
async Task<bool> AddToken()
|
|
{
|
|
try
|
|
{
|
|
var tokenUrl = $"{adminPath}/connect/token";
|
|
var formData = new List<KeyValuePair<string, string>>
|
|
{
|
|
new KeyValuePair<string, string>("client_id", "admin"),
|
|
new KeyValuePair<string, string>("client_secret", "secret"),
|
|
new KeyValuePair<string, string>("scope", "admin"),
|
|
new KeyValuePair<string, string>("grant_type", "client_credentials")
|
|
};
|
|
var content = new FormUrlEncodedContent(formData);
|
|
|
|
var response = await _httpClient.PostAsync(tokenUrl, content);
|
|
var responseContent = await response.Content.ReadAsStringAsync();
|
|
if (!response.IsSuccessStatusCode)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
_token = JsonConvert.DeserializeObject<BearerToken>(responseContent);
|
|
var configPath = $"{adminPath}/.well-known/openid-configuration";
|
|
response = await _httpClient.GetAsync(configPath);
|
|
return response.IsSuccessStatusCode;
|
|
}
|
|
catch (Exception)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
var addToken = await Wait.WaitFor(40000).Until(async () =>
|
|
{
|
|
var result = await AddToken();
|
|
Thread.Sleep(1000);
|
|
return result;
|
|
});
|
|
|
|
addToken.ShouldBeTrue();
|
|
}
|
|
|
|
private void GivenThereIsAConfiguration(FileConfiguration fileConfiguration)
|
|
{
|
|
var configurationPath = $"{Directory.GetCurrentDirectory()}/ocelot.json";
|
|
|
|
var jsonConfiguration = JsonConvert.SerializeObject(fileConfiguration);
|
|
|
|
if (File.Exists(configurationPath))
|
|
{
|
|
File.Delete(configurationPath);
|
|
}
|
|
|
|
File.WriteAllText(configurationPath, jsonConfiguration);
|
|
|
|
var text = File.ReadAllText(configurationPath);
|
|
|
|
configurationPath = $"{AppContext.BaseDirectory}/ocelot.json";
|
|
|
|
if (File.Exists(configurationPath))
|
|
{
|
|
File.Delete(configurationPath);
|
|
}
|
|
|
|
File.WriteAllText(configurationPath, jsonConfiguration);
|
|
|
|
text = File.ReadAllText(configurationPath);
|
|
}
|
|
|
|
private void GivenAServerIsRunning(string url)
|
|
{
|
|
lock (_lock)
|
|
{
|
|
IWebHostBuilder webHostBuilder = new WebHostBuilder();
|
|
webHostBuilder.UseUrls(url)
|
|
.UseKestrel()
|
|
.UseContentRoot(Directory.GetCurrentDirectory())
|
|
.ConfigureAppConfiguration((hostingContext, config) =>
|
|
{
|
|
config.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath);
|
|
var env = hostingContext.HostingEnvironment;
|
|
config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: false)
|
|
.AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: false);
|
|
config.AddJsonFile("ocelot.json", false, false);
|
|
config.AddJsonFile("peers.json", optional: true, reloadOnChange: false);
|
|
#pragma warning disable CS0618
|
|
config.AddOcelotBaseUrl(url);
|
|
#pragma warning restore CS0618
|
|
config.AddEnvironmentVariables();
|
|
})
|
|
.ConfigureServices(x =>
|
|
{
|
|
x.AddSingleton(new NodeId(url));
|
|
x
|
|
.AddOcelot()
|
|
.AddAdministration("/administration", "secret")
|
|
.AddRafty();
|
|
})
|
|
.Configure(app =>
|
|
{
|
|
app.UseOcelot().Wait();
|
|
});
|
|
|
|
var builder = webHostBuilder.Build();
|
|
builder.Start();
|
|
|
|
_webHostBuilders.Add(webHostBuilder);
|
|
_builders.Add(builder);
|
|
}
|
|
}
|
|
|
|
private void GivenFiveServersAreRunning()
|
|
{
|
|
var bytes = File.ReadAllText("peers.json");
|
|
_peers = JsonConvert.DeserializeObject<FilePeers>(bytes);
|
|
|
|
foreach (var peer in _peers.Peers)
|
|
{
|
|
File.Delete(peer.HostAndPort.Replace("/", "").Replace(":", ""));
|
|
File.Delete($"{peer.HostAndPort.Replace("/", "").Replace(":", "")}.db");
|
|
var thread = new Thread(() => GivenAServerIsRunning(peer.HostAndPort));
|
|
thread.Start();
|
|
_threads.Add(thread);
|
|
}
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
foreach (var builder in _builders)
|
|
{
|
|
builder?.Dispose();
|
|
}
|
|
|
|
foreach (var peer in _peers.Peers)
|
|
{
|
|
try
|
|
{
|
|
File.Delete(peer.HostAndPort.Replace("/", "").Replace(":", ""));
|
|
File.Delete($"{peer.HostAndPort.Replace("/", "").Replace(":", "")}.db");
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Console.WriteLine(e);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|