internal static IServer CreateDynamicHttpsServer(string basePath, out string root, out string baseAddress, Action <HttpSysOptions> configureOptions, RequestDelegate app, ILoggerFactory loggerFactory = null)
{
lock (PortLock)
{
while (NextHttpsPort < MaxHttpsPort)
{
var port = NextHttpsPort++;
var prefix = UrlPrefix.Create("https", "localhost", port, basePath);
root = prefix.Scheme + "://" + prefix.Host + ":" + prefix.Port;
baseAddress = prefix.ToString();
var server = CreatePump(loggerFactory);
server.Features.Get <IServerAddressesFeature>().Addresses.Add(baseAddress);
configureOptions(server.Listener.Options);
try
{
server.StartAsync(new DummyApplication(app), CancellationToken.None).Wait();
return(server);
}
catch (HttpSysException)
{
}
}
NextHttpsPort = BaseHttpsPort;
}
throw new Exception("Failed to locate a free port.");
}
public void RemoveLeadingSegmentsCanMatchEntireUrl()
{
var prefix = new UrlPrefix("foo");
Assert.Equal(prefix.RemoveLeadingSegments("~/foo/"), ("~/"));
Assert.Equal(prefix.RemoveLeadingSegments("~/foo"), ("~/"));
}
public void RemoveLeadingSegmentsIsCaseInsensitive()
{
var prefix = new UrlPrefix("Foo");
Assert.Equal(prefix.RemoveLeadingSegments("~/foo/bar"), ("~/bar"));
Assert.Equal(prefix.RemoveLeadingSegments("~/FOO/BAR"), ("~/BAR"));
}
internal static IHost CreateDynamicHost(string basePath, out string root, out string baseAddress, Action <HttpSysOptions> configureOptions, RequestDelegate app)
{
var prefix = UrlPrefix.Create("http", "localhost", "0", basePath);
var builder = new HostBuilder()
.ConfigureWebHost(webHostBuilder =>
{
webHostBuilder
.UseHttpSys(options =>
{
options.UrlPrefixes.Add(prefix);
configureOptions(options);
})
.Configure(appBuilder => appBuilder.Run(app));
});
var host = builder.Build();
host.Start();
var options = host.Services.GetRequiredService <IOptions <HttpSysOptions> >();
prefix = options.Value.UrlPrefixes.First(); // Has new port
root = prefix.Scheme + "://" + prefix.Host + ":" + prefix.Port;
baseAddress = prefix.ToString();
return(host);
}
private static void Listen(KestrelServerOptions options, IConfigurationRoot config, string url)
{
var urlPrefix = UrlPrefix.Create(url);
var endpoint = CreateIPEndPoint(urlPrefix);
options.Listen(endpoint, listenOptions =>
{
var connectionFilter = GetConnectionFilter(config);
if (connectionFilter != null)
{
listenOptions.ConnectionAdapters.Add(connectionFilter);
}
#if !NETCOREAPP2_0 && !NETCOREAPP2_1
if (Protocol.Equals("h2", StringComparison.OrdinalIgnoreCase))
{
listenOptions.Protocols = HttpProtocols.Http1AndHttp2;
}
else if (Protocol.Equals("h2c", StringComparison.OrdinalIgnoreCase))
{
listenOptions.Protocols = HttpProtocols.Http2;
}
#endif
if (urlPrefix.IsHttps)
{
listenOptions.UseHttps("testCert.pfx", "testPassword");
}
});
}
public async Task Request_MultiplePrefixes(string requestUri, string expectedPathBase, string expectedPath)
{
// TODO: We're just doing this to get a dynamic port. This can be removed later when we add support for hot-adding prefixes.
string root;
var server = Utilities.CreateHttpServerReturnRoot("/", out root);
server.Dispose();
server = new HttpSysListener(new HttpSysOptions(), new LoggerFactory());
using (server)
{
var uriBuilder = new UriBuilder(root);
foreach (string path in new[] { "/", "/11", "/2/3", "/2", "/11/2" })
{
server.Options.UrlPrefixes.Add(UrlPrefix.Create(uriBuilder.Scheme, uriBuilder.Host, uriBuilder.Port, path));
}
server.Start();
Task <string> responseTask = SendRequestAsync(root + requestUri);
var context = await server.AcceptAsync(Utilities.DefaultTimeout);
var request = context.Request;
Assert.Equal(expectedPath, request.Path);
Assert.Equal(expectedPathBase, request.PathBase);
context.Dispose();
string response = await responseTask;
Assert.Equal(string.Empty, response);
}
}
internal static HttpSysListener CreateDynamicHttpServer(string basePath, out string root, out string baseAddress)
{
lock (PortLock)
{
while (NextPort < MaxPort)
{
var port = NextPort++;
var prefix = UrlPrefix.Create("http", "localhost", port, basePath);
root = prefix.Scheme + "://" + prefix.Host + ":" + prefix.Port;
baseAddress = prefix.ToString();
var options = new HttpSysOptions();
options.UrlPrefixes.Add(prefix);
options.RequestQueueName = prefix.Port; // Convention for use with CreateServerOnExistingQueue
var listener = new HttpSysListener(options, new LoggerFactory());
try
{
listener.Start();
return(listener);
}
catch (HttpSysException ex)
{
listener.Dispose();
if (ex.ErrorCode != UnsafeNclNativeMethods.ErrorCodes.ERROR_ALREADY_EXISTS &&
ex.ErrorCode != UnsafeNclNativeMethods.ErrorCodes.ERROR_SHARING_VIOLATION &&
ex.ErrorCode != UnsafeNclNativeMethods.ErrorCodes.ERROR_ACCESS_DENIED)
{
throw;
}
}
}
NextPort = BasePort;
}
throw new Exception("Failed to locate a free port.");
}
private void ParseAddresses(ICollection <string> addresses, Microsoft.Net.Http.Server.WebListener listener)
{
foreach (var value in addresses)
{
listener.UrlPrefixes.Add(UrlPrefix.Create(value));
}
}
internal static IServer CreateDynamicHttpServer(string basePath, AuthenticationSchemes authType, out string root, out string baseAddress, RequestDelegate app)
{
lock (PortLock)
{
while (NextPort < MaxPort)
{
var port = NextPort++;
var prefix = UrlPrefix.Create("http", "localhost", port, basePath);
root = prefix.Scheme + "://" + prefix.Host + ":" + prefix.Port;
baseAddress = prefix.ToString();
var server = new MessagePump(Options.Create(new WebListenerOptions()), new LoggerFactory());
server.Features.Get <IServerAddressesFeature>().Addresses.Add(baseAddress);
server.Listener.AuthenticationManager.AuthenticationSchemes = authType;
try
{
server.Start(new DummyApplication(app));
return(server);
}
catch (WebListenerException)
{
}
}
NextPort = BasePort;
}
throw new Exception("Failed to locate a free port.");
}
internal static HttpSysListener CreateDynamicHttpServer(string basePath, out string root, out string baseAddress)
{
lock (PortLock)
{
while (NextPort < MaxPort)
{
var port = NextPort++;
var prefix = UrlPrefix.Create("http", "localhost", port, basePath);
root = prefix.Scheme + "://" + prefix.Host + ":" + prefix.Port;
baseAddress = prefix.ToString();
var listener = new HttpSysListener(new HttpSysOptions(), new LoggerFactory());
listener.Options.UrlPrefixes.Add(prefix);
try
{
listener.Start();
return(listener);
}
catch (HttpSysException)
{
listener.Dispose();
}
}
NextPort = BasePort;
}
throw new Exception("Failed to locate a free port.");
}
public void PathBaseIsNotNormalized()
{
var urlPrefix = UrlPrefix.Create("http://localhost:8080/p\u0041\u030Athbase");
Assert.False(urlPrefix.Path.IsNormalized(NormalizationForm.FormC));
Assert.Equal("/p\u0041\u030Athbase/", urlPrefix.Path);
}
public void PrependLeadingSegmentsPreservesNatureOfIncomingPath()
{
var prefix = new UrlPrefix("foo");
Assert.Equal(prefix.PrependLeadingSegments("~/bar"), ("~/foo/bar"));
Assert.Equal(prefix.PrependLeadingSegments("/bar"), ("/foo/bar"));
Assert.Equal(prefix.PrependLeadingSegments("bar"), ("foo/bar"));
}
public void RemoveLeadingSegmentsMayContainSlash()
{
var prefix = new UrlPrefix("foo/quux");
Assert.Equal(prefix.RemoveLeadingSegments("~/foo/quux/bar"), ("~/bar"));
Assert.Equal(prefix.RemoveLeadingSegments("~/foo/bar"), ("~/foo/bar"));
Assert.Equal(prefix.RemoveLeadingSegments("~/quux/bar"), ("~/quux/bar"));
}
internal static IServer CreateServer(string scheme, string host, int port, string path, RequestDelegate app)
{
var server = new MessagePump(Options.Create(new WebListenerOptions()), new LoggerFactory());
server.Features.Get <IServerAddressesFeature>().Addresses.Add(UrlPrefix.Create(scheme, host, port, path).ToString());
server.Start(new DummyApplication(app));
return(server);
}
public void RemoveLeadingSegmentsOnlyMatchesFullSegment()
{
var prefix = new UrlPrefix("foo");
Assert.Equal(prefix.RemoveLeadingSegments("~/foo/bar"), ("~/bar"));
Assert.Equal(prefix.RemoveLeadingSegments("~/fooo/bar"), ("~/fooo/bar"));
Assert.Equal(prefix.RemoveLeadingSegments("~/fo/bar"), ("~/fo/bar"));
}
internal static HttpSysListener CreateServer(string scheme, string host, int port, string path)
{
var listener = new HttpSysListener(new HttpSysOptions(), new LoggerFactory());
listener.Options.UrlPrefixes.Add(UrlPrefix.Create(scheme, host, port, path));
listener.Start();
return(listener);
}
public void PrependLeadingSegmentsHandlesShortUrlConditionsAppropriately()
{
var prefix = new UrlPrefix("foo");
Assert.Equal(prefix.PrependLeadingSegments("~/"), ("~/foo/"));
Assert.Equal(prefix.PrependLeadingSegments("/"), ("/foo/"));
Assert.Equal(prefix.PrependLeadingSegments("~"), ("~/foo/"));
Assert.Equal(prefix.PrependLeadingSegments(""), ("foo/"));
}
protected override string ConfigureServer(HttpSysOptions options, string baseServerAddress)
{
options.RequestQueueMode = RequestQueueMode.CreateOrAttach;
var basePrefix = UrlPrefix.Create(baseServerAddress);
var prefix = UrlPrefix.Create(basePrefix.Scheme, basePrefix.Host, basePrefix.Port, "/server");
options.UrlPrefixes.Add(prefix);
return(prefix.ToString());
}
public WidgetsContainerPartHandler(
IContentManager contentManager,
IWidgetManager widgetManager,
ILocalizationService localizationService,
ShellSettings shellSettings,
ITaxonomyService taxonomyService)
{
_contentManager = contentManager;
_widgetManager = widgetManager;
_localizationService = localizationService;
_shellSettings = shellSettings;
_taxonomyService = taxonomyService;
if (!string.IsNullOrEmpty(_shellSettings.RequestUrlPrefix))
{
_urlPrefix = new UrlPrefix(_shellSettings.RequestUrlPrefix);
}
T = NullLocalizer.Instance;
OnRemoved <WidgetsContainerPart>((context, part) => {
DeleteWidgets(part);
});
OnUpdateEditorShape <WidgetsContainerPart>((context, part) => {
var lPart = part.ContentItem.As <LocalizationPart>();
if (lPart != null)
{
var settings = part.Settings.GetModel <WidgetsContainerSettings>();
if (settings.TryToLocalizeItems)
{
var culture = lPart.Culture;
var widgets = _widgetManager.GetWidgets(part.ContentItem.Id, part.ContentItem.IsPublished())
.Where(p => p.ContentItem.Has <LocalizationPart>() &&
p.ContentItem.Get <LocalizationPart>().Culture == null);
foreach (var widget in widgets)
{
var ci = widget.ContentItem;
_localizationService.SetContentCulture(ci, culture.Culture);
// manage taxonomy field out of the normal flow:
// gets translations of selected terms in taxonomy fields before BuildEditor()
var translatedTaxo = TranslateTaxonomies(ci, culture, _localizationService);
// simulates a user that opens in edit model the widget and saves it
// to trigger all handlers and drivers
var shapeWidget = _contentManager.BuildEditor(ci);
var shapeUpdate = _contentManager.UpdateEditor(ci, new CustomUpdater(shapeWidget, culture.Culture, Logger));
// sets translated terms in taxonomy fields after UpdateEditor()
ApplyTranslatedTaxonomies(ci, translatedTaxo, _taxonomyService);
ci.VersionRecord.Published = false;
_contentManager.Publish(ci);
}
}
}
});
}
public void UrlsAreParsedCorrectly(string url, string scheme, string host, string port, string pathBase, string toString)
{
var urlPrefix = UrlPrefix.Create(url);
Assert.Equal(scheme, urlPrefix.Scheme);
Assert.Equal(host, urlPrefix.Host);
Assert.Equal(port, urlPrefix.Port);
Assert.Equal(pathBase, urlPrefix.Path);
Assert.Equal(toString ?? url, urlPrefix.ToString());
}
internal static AzureRelayListener CreateServer(string baseUrl, string path)
{
var listener = new AzureRelayListener(new AzureRelayOptions()
{
TokenProvider = Microsoft.Azure.Relay.AspNetCore.Utilities.CreateTokenProvider()
}, new LoggerFactory());
listener.Options.UrlPrefixes.Add(UrlPrefix.Create(new Uri(new Uri(baseUrl), path).AbsoluteUri));
listener.Start();
return(listener);
}
public static string RetrieveHostUrl(string url)
{
if (!string.IsNullOrEmpty(url))
{
var uri = UrlPrefix.Create(url);
if (uri.Host == "+" || uri.Host == "*")
{
return(uri.Scheme + "://localhost:" + uri.Port);
}
}
return(url);
}
public void RemoveLeadingSegmentsIgnoreLeadingAndTrailingCharactersOnInput()
{
var prefix = new UrlPrefix("foo");
Assert.Equal(prefix.RemoveLeadingSegments("~/foo/bar"), ("~/bar"));
var prefix2 = new UrlPrefix("~/foo");
Assert.Equal(prefix2.RemoveLeadingSegments("~/foo/bar"), ("~/bar"));
var prefix3 = new UrlPrefix("foo/");
Assert.Equal(prefix3.RemoveLeadingSegments("~/foo/bar"), ("~/bar"));
}
public void Server_RegisterUnavailablePrefix_ThrowsActionableHttpSysException()
{
var options = new HttpSysOptions();
options.UrlPrefixes.Add(UrlPrefix.Create("http", "example.org", "8080", ""));
var listener = new HttpSysListener(options, new LoggerFactory());
var exception = Assert.Throws <HttpSysException>(() => listener.Start());
Assert.Equal((int)UnsafeNclNativeMethods.ErrorCodes.ERROR_ACCESS_DENIED, exception.ErrorCode);
Assert.Contains($@"netsh http add urlacl url=http://example.org:8080/ user={Environment.UserDomainName}\{Environment.UserName}", exception.Message);
}
public async Task Server_ConnectExistingQueueName_Success(RequestQueueMode queueMode)
{
string address;
var queueName = Guid.NewGuid().ToString();
// First create the queue.
HttpRequestQueueV2Handle requestQueueHandle = null;
var statusCode = HttpApi.HttpCreateRequestQueue(
HttpApi.Version,
queueName,
IntPtr.Zero,
0,
out requestQueueHandle);
Assert.True(statusCode == UnsafeNclNativeMethods.ErrorCodes.ERROR_SUCCESS);
// Now attach to the existing one
using (Utilities.CreateHttpServer(out address, httpContext =>
{
return(Task.FromResult(0));
}, options =>
{
options.RequestQueueName = queueName;
options.RequestQueueMode = queueMode;
}))
{
var psi = new ProcessStartInfo("netsh", "http show servicestate view=requestq")
{
RedirectStandardOutput = true
};
using var process = Process.Start(psi);
process.Start();
var netshOutput = await process.StandardOutput.ReadToEndAsync();
Assert.Contains(queueName, netshOutput);
var prefix = UrlPrefix.Create(address);
switch (queueMode)
{
case RequestQueueMode.Attach:
Assert.Equal("0", prefix.Port);
break;
case RequestQueueMode.CreateOrAttach:
Assert.NotEqual("0", prefix.Port);
Assert.Contains(address, netshOutput, StringComparison.OrdinalIgnoreCase);
break;
}
}
}
public void StartProcess(ProcessHostInfo host)
{
if (string.IsNullOrWhiteSpace(host?.Domain))
{
return;
}
string startupArgs = $"/urls=\"{UrlPrefix.Create("http", host.Domain, host.Port, string.Empty)}\" /process=child";
var process = GetOrphanedProcess(startupArgs, host)
?? new ChildProcess(host, startupArgs, _logger);
process.StartTime = DateTime.Now;
StartProcess(process);
}
private static IPEndPoint CreateIPEndPoint(UrlPrefix urlPrefix)
{
IPAddress ip;
if (string.Equals(urlPrefix.Host, "localhost", StringComparison.OrdinalIgnoreCase))
{
ip = IPAddress.Loopback;
}
else if (!IPAddress.TryParse(urlPrefix.Host, out ip))
{
ip = IPAddress.IPv6Any;
}
return(new IPEndPoint(ip, urlPrefix.PortValue));
}
internal static IServer CreateDynamicHttpServer(string basePath, out string root, out string baseAddress, Action <HttpSysOptions> configureOptions, RequestDelegate app)
{
var prefix = UrlPrefix.Create("http", "localhost", "0", basePath);
var server = CreatePump(configureOptions);
server.Features.Get <IServerAddressesFeature>().Addresses.Add(prefix.ToString());
server.StartAsync(new DummyApplication(app), CancellationToken.None).Wait();
prefix = server.Listener.Options.UrlPrefixes.First(); // Has new port
root = prefix.Scheme + "://" + prefix.Host + ":" + prefix.Port;
baseAddress = prefix.ToString();
return(server);
}
public bool TryAdd(object instanceOrReplica, out PathString urlPrefix)
{
if (instanceOrReplica == null)
{
throw new ArgumentNullException(nameof(instanceOrReplica));
}
if (!(instanceOrReplica is IStatelessServiceInstance) && !(instanceOrReplica is IStatefulServiceReplica))
{
throw new ArgumentException(null, nameof(instanceOrReplica));
}
urlPrefix = UrlPrefix.NewUrlPrefix();
return(ImmutableInterlocked.TryAdd(ref _entries, urlPrefix, instanceOrReplica));
}
private IServer CreateServer(out string root, RequestDelegate app)
{
// TODO: We're just doing this to get a dynamic port. This can be removed later when we add support for hot-adding prefixes.
var dynamicServer = Utilities.CreateHttpServerReturnRoot("/", out root, app);
dynamicServer.Dispose();
var rootUri = new Uri(root);
var server = new MessagePump(Options.Create(new WebListenerOptions()), new LoggerFactory());
foreach (string path in new[] { "/", "/11", "/2/3", "/2", "/11/2" })
{
server.Listener.UrlPrefixes.Add(UrlPrefix.Create(rootUri.Scheme, rootUri.Host, rootUri.Port, path));
}
server.Start(new DummyApplication(app));
return(server);
}
