public HttpContext Create(IFeatureCollection featureCollection)
{
PooledHttpContext httpContext = null;
lock (_pool)
{
if (_pool.Count != 0)
{
httpContext = _pool.Pop();
}
}
if (httpContext == null)
{
httpContext = new PooledHttpContext(featureCollection);
}
else
{
httpContext.Initialize(featureCollection);
}
if (_httpContextAccessor != null)
{
_httpContextAccessor.HttpContext = httpContext;
}
return httpContext;
}
/// <summary>
/// Protected constructor for the abstract class.
/// </summary>
/// <param name="httpClientUtil">A configured <see cref="HttpClientUtil"/> instance for performing web requests</param>
/// <param name="featureTypeInfo">A <see cref="WfsFeatureTypeInfo"/> instance providing metadata of the featuretype to query</param>
/// <param name="labelInfo">A FeatureDataTable for labels</param>
protected GeometryFactory(HttpClientUtil httpClientUtil, WfsFeatureTypeInfo featureTypeInfo,
IFeatureCollection labelInfo)
{
_FeatureTypeInfo = featureTypeInfo;
Factory = featureTypeInfo.Factory;
_HttpClientUtil = httpClientUtil;
createReader(httpClientUtil);
try
{
if (labelInfo != null)
{
_LabelInfo = labelInfo;
_LabelNode = new PathNode(_FeatureTypeInfo.FeatureTypeNamespace, _LabelInfo.AttributesDefinition[0].AttributeName,
(NameTable) _XmlReader.NameTable);
}
}
catch (Exception ex)
{
Trace.TraceError("An exception occured while initializing the label path node!");
throw ex;
}
initializePathNodes();
initializeSeparators();
}
public HttpContext Create(IFeatureCollection featureCollection)
{
if (featureCollection == null)
{
throw new ArgumentNullException(nameof(featureCollection));
}
var responseCookiesFeature = new ResponseCookiesFeature(featureCollection, _builderPool);
featureCollection.Set<IResponseCookiesFeature>(responseCookiesFeature);
PooledHttpContext httpContext = null;
lock (_pool)
{
if (_pool.Count != 0)
{
httpContext = _pool.Pop();
}
}
if (httpContext == null)
{
httpContext = new PooledHttpContext(featureCollection);
}
else
{
httpContext.Initialize(featureCollection);
}
if (_httpContextAccessor != null)
{
_httpContextAccessor.HttpContext = httpContext;
}
return httpContext;
}
public IDisposable Start(IFeatureCollection serverFeatures, Func<IFeatureCollection, Task> application)
{
var information = (NowinServerInformation)serverFeatures.Get<NowinServerInformation>();
_callback = application;
INowinServer server = information.Builder.Build();
server.Start();
return server;
}
public DefaultHttpContext(IFeatureCollection features)
{
_features = features;
_request = new DefaultHttpRequest(this, features);
_response = new DefaultHttpResponse(this, features);
_connection = new DefaultConnectionInfo(features);
_authenticationManager = new DefaultAuthenticationManager(features);
}
public RequestCookiesFeature(IFeatureCollection features)
{
if (features == null)
{
throw new ArgumentNullException(nameof(features));
}
_features = features;
}
public RequestCookiesFeature(IFeatureCollection features)
{
if (features == null)
{
throw new ArgumentNullException(nameof(features));
}
_features = new FeatureReferences<IHttpRequestFeature>(features);
}
public QueryFeature(IFeatureCollection features)
{
if (features == null)
{
throw new ArgumentNullException(nameof(features));
}
_features = features;
}
public HttpContext Create(IFeatureCollection featureCollection)
{
var httpContext = new DefaultHttpContext(featureCollection);
if (_httpContextAccessor != null)
{
_httpContextAccessor.HttpContext = httpContext;
}
return httpContext;
}
public IDisposable Start(IFeatureCollection serverFeatures, Func<IFeatureCollection, Task> application)
{
var builder = ServerBuilder.New()
.SetAddress(IPAddress.Any)
.SetPort(5000)
.SetOwinApp(OwinWebSocketAcceptAdapter.AdaptWebSockets(HandleRequest));
_callback = application;
var server = builder.Build();
server.Start();
return server;
}
private async Task AppChunked(IFeatureCollection frame)
{
var request = frame.Get<IHttpRequestFeature>();
var response = frame.Get<IHttpResponseFeature>();
var data = new MemoryStream();
await request.Body.CopyToAsync(data);
var bytes = data.ToArray();
response.Headers.Clear();
response.Headers["Content-Length"] = bytes.Length.ToString();
await response.Body.WriteAsync(bytes, 0, bytes.Length);
}
public DefaultHttpContext(IFeatureCollection features)
{
_features = features;
_request = new DefaultHttpRequest(this, features);
_response = new DefaultHttpResponse(this, features);
_items = FeatureReference<IItemsFeature>.Default;
_serviceProviders = FeatureReference<IServiceProvidersFeature>.Default;
_authentication = FeatureReference<IHttpAuthenticationFeature>.Default;
_lifetime = FeatureReference<IHttpRequestLifetimeFeature>.Default;
_webSockets = FeatureReference<IHttpWebSocketFeature>.Default;
_session = FeatureReference<ISessionFeature>.Default;
}
protected override string FormatRows(IFeatureCollection rows, int[] keys, int maxFeatures)
{
StringBuilder sb = new StringBuilder();
var attributeDefinition = rows[0].Factory.AttributesDefinition;
for (int k = 0; k < maxFeatures; k++)
{
string css = k % 2 == 0 ? CssEven : CssOdd;
int key = keys[k];
sb.AppendFormat("<tr{0}>{1}", css, NewLine);
for (var i = 0; i < attributeDefinition.Count;i++)
sb.AppendFormat("<td>{0}</td>{1}", rows[key].Attributes[i], NewLine);
sb.AppendFormat("</tr>{0}", NewLine);
}
return sb.ToString();
}
private async Task App(IFeatureCollection frame)
{
var request = frame.Get<IHttpRequestFeature>();
var response = frame.Get<IHttpResponseFeature>();
response.Headers.Clear();
while (true)
{
var buffer = new byte[8192];
var count = await request.Body.ReadAsync(buffer, 0, buffer.Length);
if (count == 0)
{
break;
}
await response.Body.WriteAsync(buffer, 0, count);
}
}
protected override string FormatRows(IFeatureCollection rows, int[] keys, int maxFeatures)
{
StringBuilder sb = new StringBuilder();
var attributeDefinition = rows[0].Factory.AttributesDefinition;
for (int k = 0; k < maxFeatures; k++)
{
int key = keys[k];
var length = attributeDefinition.Count;
for (int i = 0; i < length; i++)
{
var separator = (i == length - 1) ? String.Empty : " ";
sb.AppendFormat("'{0}'{1}", rows[key].Attributes[i], separator);
}
if ((k + 1) < maxFeatures)
sb.AppendFormat(",{0}", NewLine);
}
return sb.ToString();
}
protected string GetRowsText(IFeatureCollection rows, int maxFeatures)
{
// if featurecount < fds...count, select smallest bbox, because most likely to be clicked
int[] keys = new int[rows.Count];
double[] area = new double[rows.Count];
for (int i = 0; i < rows.Count; i++)
{
IFeature row = rows[i];
IGeometry geometry = row.Geometry;
Envelope envelope = geometry.EnvelopeInternal;
area[i] = envelope.Area;
keys[i] = i;
}
Array.Sort(area, keys);
if (rows.Count < maxFeatures)
maxFeatures = rows.Count;
return FormatRows(rows, keys, maxFeatures);
}
public HttpContext Create(IFeatureCollection featureCollection)
{
if (featureCollection == null)
{
throw new ArgumentNullException(nameof(featureCollection));
}
var responseCookiesFeature = new ResponseCookiesFeature(featureCollection, _builderPool);
featureCollection.Set<IResponseCookiesFeature>(responseCookiesFeature);
var httpContext = new DefaultHttpContext(featureCollection);
if (_httpContextAccessor != null)
{
_httpContextAccessor.HttpContext = httpContext;
}
var formFeature = new FormFeature(httpContext.Request, _formOptions);
featureCollection.Set<IFormFeature>(formFeature);
return httpContext;
}
public CustomListenerHost(IFeatureCollection featureCollection, IListen listener)
{
Features = featureCollection ?? throw new ArgumentNullException(nameof(featureCollection));
_listener = listener ?? throw new ArgumentNullException(nameof(listener));
}
public virtual void Initialize(IFeatureCollection features)
{
_features = new FeatureReferences<FeatureInterfaces>(features);
}
public void Initalize(IFeatureCollection collection, int revision)
{
Revision = revision;
Collection = collection;
}
public void Initialize(IFeatureCollection features)
{
_features.Initalize(features);
}
public HttpResponse(IFeatureCollection features)
{
feature = features.Get <IHttpResponseFeature>();
}
private static bool CheckRequest(IFeatureCollection x, IHandledMessage message, byte[] body)
{
x.Get <IHttpRequestFeature>().Headers[HeaderConstants.MessageId].ToString().Should().Be(message.Properties.MessageId);
((MemoryStream)x.Get <IHttpRequestFeature>().Body).ToArray().Should().BeEquivalentTo(body);
return(true);
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultHttpContext"/> class with provided features.
/// </summary>
/// <param name="features">Initial set of features for the <see cref="DefaultHttpContext"/>.</param>
public DefaultHttpContext(IFeatureCollection features)
{
_features.Initalize(features);
_request = new DefaultHttpRequest(this);
_response = new DefaultHttpResponse(this);
}
/// <summary>
/// Initializes a new instance of the <see cref="MultiLineStringFactory"/> class.
/// </summary>
/// <param name="httpClientUtil">A configured <see cref="HttpClientUtil"/> instance for performing web requests</param>
/// <param name="featureTypeInfo">A <see cref="WfsFeatureTypeInfo"/> instance providing metadata of the featuretype to query</param>
/// <param name="labelInfo">A FeatureDataTable for labels</param>
internal MultiLineStringFactory(HttpClientUtil httpClientUtil, WfsFeatureTypeInfo featureTypeInfo,
IFeatureCollection labelInfo)
: base(httpClientUtil, featureTypeInfo, labelInfo)
{
}
/// <summary>
/// Initializes a new <see cref="ResponseCookiesFeature"/> instance.
/// </summary>
/// <param name="features">
/// <see cref="IFeatureCollection"/> containing all defined features, including this
/// <see cref="IResponseCookiesFeature"/> and the <see cref="IHttpResponseFeature"/>.
/// </param>
public ResponseCookiesFeature(IFeatureCollection features)
: this(features, builderPool : null)
{
}
public FormFeature([NotNull] IFeatureCollection features)
{
_features = features;
}
public BundleHandlerTests()
{
_router = Substitute.For <IRouter>();
_fhirRequestContext = new DefaultFhirRequestContext
{
BaseUri = new Uri("https://localhost/"),
CorrelationId = Guid.NewGuid().ToString(),
ResponseHeaders = new HeaderDictionary(),
};
var fhirRequestContextAccessor = Substitute.For <RequestContextAccessor <IFhirRequestContext> >();
fhirRequestContextAccessor.RequestContext.Returns(_fhirRequestContext);
IHttpContextAccessor httpContextAccessor = Substitute.For <IHttpContextAccessor>();
var fhirJsonSerializer = new FhirJsonSerializer();
var fhirJsonParser = new FhirJsonParser();
ISearchService searchService = Substitute.For <ISearchService>();
var resourceReferenceResolver = new ResourceReferenceResolver(searchService, new QueryStringParser());
var transactionBundleValidator = new TransactionBundleValidator(resourceReferenceResolver);
var bundleHttpContextAccessor = new BundleHttpContextAccessor();
IFeatureCollection featureCollection = CreateFeatureCollection();
var httpContext = new DefaultHttpContext(featureCollection)
{
Request =
{
Scheme = "https",
Host = new HostString("localhost"),
PathBase = new PathString("/"),
},
};
httpContextAccessor.HttpContext.Returns(httpContext);
var transactionHandler = Substitute.For <ITransactionHandler>();
var resourceIdProvider = new ResourceIdProvider();
IAuditEventTypeMapping auditEventTypeMapping = Substitute.For <IAuditEventTypeMapping>();
_bundleConfiguration = new BundleConfiguration();
var bundleOptions = Substitute.For <IOptions <BundleConfiguration> >();
bundleOptions.Value.Returns(_bundleConfiguration);
_mediator = Substitute.For <IMediator>();
_bundleHandler = new BundleHandler(
httpContextAccessor,
fhirRequestContextAccessor,
fhirJsonSerializer,
fhirJsonParser,
transactionHandler,
bundleHttpContextAccessor,
resourceIdProvider,
transactionBundleValidator,
resourceReferenceResolver,
auditEventTypeMapping,
bundleOptions,
DisabledFhirAuthorizationService.Instance,
_mediator,
NullLogger <BundleHandler> .Instance);
}
internal override object CreateContext(IFeatureCollection features)
{
return(((IHttpApplication <TestHostingContext>) this).CreateContext(features));
}
public void Finish(IFeatureCollection collection)
{
_timeFeature = collection.GetFeature <ITimeStepsFeature>();
_calculationDateIndices = _calculationDates.Select(d => _timeFeature.GetDateIndex(d)).ToArray();
_isComplete = true;
}
public RequestCookiesFeature([NotNull] IFeatureCollection features)
{
_features = features;
}
public DefaultHttpContext(IFeatureCollection features)
{
Initialize(features);
}
public static IFeatureCollection Set <T>(this IFeatureCollection features, T feature)
{
features[typeof(T)] = feature;
return(features);
}
public virtual void Initialize(IFeatureCollection features)
{
_features = new FeatureReferences <FeatureInterfaces>(features);
_request = InitializeHttpRequest();
_response = InitializeHttpResponse();
}
public DefaultHttpRequest(DefaultHttpContext context, IFeatureCollection features)
{
_context = context;
_features = features;
}
/// <summary>
/// For use with IHostBuilder or IWebHostBuilder.
/// </summary>
/// <param name="featureCollection"></param>
public TestServer(IFeatureCollection featureCollection)
{
Features = featureCollection ?? throw new ArgumentNullException(nameof(featureCollection));
}
public TContext CreateContext(IFeatureCollection contextFeatures)
{
return(_application.CreateContext(contextFeatures));
}
public FeatureCollection(IFeatureCollection defaults)
{
_defaults = defaults;
}
public FeatureReferences(IFeatureCollection collection)
{
Collection = collection;
Cache = default;
Revision = collection.Revision;
}
internal abstract object CreateContext(IFeatureCollection features);
public DefaultConnectionInfo(IFeatureCollection features)
{
Initialize(features);
}
public Task Invoke(IFeatureCollection featureCollection)
{
if (_disposed)
{
throw new ObjectDisposedException(GetType().FullName);
}
return _appDelegate(featureCollection);
}
public void Initialize(IFeatureCollection features, int revision)
{
_features.Initalize(features, revision);
}
public ResponseCookiesFeature(IFeatureCollection features)
{
_features = new FeatureReferences<IHttpResponseFeature>(features);
}
public DefaultWebSocketManager(IFeatureCollection features)
{
Initialize(features);
}
private Task EmptyApp(IFeatureCollection frame)
{
frame.Get<IHttpResponseFeature>().Headers.Clear();
return Task.FromResult<object>(null);
}
public IApplicationBuilder CreateBuilder(IFeatureCollection serverFeatures)
{
return new ApplicationBuilder(_serviceProvider, serverFeatures);
}
/// <summary>
/// Initializes a new instance of the <see cref="PolygonFactory"/> class.
/// </summary>
/// <param name="httpClientUtil">A configured <see cref="HttpClientUtil"/> instance for performing web requests</param>
/// <param name="featureTypeInfo">A <see cref="WfsFeatureTypeInfo"/> instance providing metadata of the featuretype to query</param>
/// <param name="labelInfo">A FeatureDataTable for labels</param>
internal PolygonFactory(HttpClientUtil httpClientUtil, WfsFeatureTypeInfo featureTypeInfo,
IFeatureCollection labelInfo)
: base(httpClientUtil, featureTypeInfo, labelInfo)
{
}
public void Hosting_CreatesDefaultRequestIdentifierFeature_IfNotPresent_ForImmutableFeatureCollection()
{
// Arrange
HttpContext httpContext = null;
var requestDelegate = new RequestDelegate(innerHttpContext =>
{
httpContext = innerHttpContext;
return Task.FromResult(0);
});
_featuresSupportedByThisHost = new ReadOnlyFeatureCollection();
var hostingEngine = CreateHostingEngine(requestDelegate);
// Act
var disposable = hostingEngine.Start();
// Assert
Assert.NotNull(httpContext);
Assert.IsType<HttpRequestIdentifierFeature>(httpContext.GetFeature<IHttpRequestIdentifierFeature>());
}
public ValueTask <IMultiplexedConnectionListener> BindAsync(EndPoint endpoint, IFeatureCollection features = null, CancellationToken cancellationToken = default)
{
var transport = new QuicConnectionListener(_options, _log, endpoint);
return(new ValueTask <IMultiplexedConnectionListener>(transport));
}
public DefaultHttpRequest(DefaultHttpContext context, IFeatureCollection features)
{
_context = context;
_features = features;
}
public static T Get <T>(this IFeatureCollection features) => features.TryGetValue(typeof(T), out var value) ? (T)value : default(T);
public ConsoleAppRunner(ILoggerFactory loggerFactory)
{
Features = new FeatureCollection();
}
public HttpContext(IFeatureCollection features)
{
Request = new HttpRequest(features);
Response = new HttpResponse(features);
}
/// <summary>
/// Initializes a new instance of the <see cref="UnspecifiedGeometryFactory_WFS1_0_0_GML2"/> class.
/// </summary>
/// <param name="httpClientUtil">A configured <see cref="HttpClientUtil"/> instance for performing web requests</param>
/// <param name="featureTypeInfo">A <see cref="WfsFeatureTypeInfo"/> instance providing metadata of the featuretype to query</param>
/// <param name="multiGeometries">A boolean value specifying whether multi-geometries should be created</param>
/// <param name="quickGeometries">A boolean value specifying whether the factory should create geometries quickly, but without validation</param>
/// <param name="labelInfo">A FeatureDataTable for labels</param>
internal UnspecifiedGeometryFactory_WFS1_0_0_GML2(HttpClientUtil httpClientUtil,
WfsFeatureTypeInfo featureTypeInfo, bool multiGeometries,
bool quickGeometries, IFeatureCollection labelInfo)
: base(httpClientUtil, featureTypeInfo, labelInfo)
{
_HttpClientUtil = httpClientUtil;
_MultiGeometries = multiGeometries;
_QuickGeometries = quickGeometries;
}
public static IEnumerable <Uri> GetUri(IFeatureCollection features, NacosAspNetCoreOptions config)
{
var splitChars = new char[] { ',', ';' };
var port = config.Port <= 0 ? 80 : config.Port;
// 1. config
if (!string.IsNullOrWhiteSpace(config.Ip))
{
// it seems that nacos don't return the scheme
// so here use http only.
return(new List <Uri> {
new Uri($"http://{config.Ip}:{port}")
});
}
var address = string.Empty;
// 2. IServerAddressesFeature
if (features != null)
{
var addresses = features.Get <IServerAddressesFeature>();
var addressCollection = addresses?.Addresses;
if (addressCollection != null && addressCollection.Any())
{
var uris = new List <Uri>();
foreach (var item in addressCollection)
{
var url = ReplaceAddress(item, config.PreferredNetworks);
uris.Add(new Uri(url));
}
return(uris);
}
}
// 3. ASPNETCORE_URLS
address = Environment.GetEnvironmentVariable("ASPNETCORE_URLS");
if (!string.IsNullOrWhiteSpace(address))
{
var url = ReplaceAddress(address, config.PreferredNetworks);
return(url.Split(splitChars).Select(x => new Uri(x)));
}
// 4. --urls
var cmdArgs = Environment.GetCommandLineArgs();
if (cmdArgs != null && cmdArgs.Any())
{
var cmd = cmdArgs.FirstOrDefault(x => x.StartsWith("--urls", StringComparison.OrdinalIgnoreCase));
if (!string.IsNullOrWhiteSpace(cmd))
{
address = cmd.Split('=')[1];
var url = ReplaceAddress(address, config.PreferredNetworks);
return(url.Split(splitChars).Select(x => new Uri(x)));
}
}
// 5. current ip address third
address = $"http://{GetCurrentIp(config.PreferredNetworks)}:{port}";
return(new List <Uri> {
new Uri(address)
});
}
private static bool ServerHasWebSockets(IFeatureCollection features)
{
return(features.Get <IHttpWebSocketFeature>() != null);
}
public ValueTask <MultiplexedConnectionContext> AcceptAsync(IFeatureCollection features = null, CancellationToken cancellationToken = default)
{
return(ValueTask.FromResult <MultiplexedConnectionContext>(null));
}
public HttpContext CreateContext(IFeatureCollection contextFeatures)
{
return(new DefaultHttpContext(contextFeatures));
}
public HttpContext CreateContext(IFeatureCollection contextFeatures)
{
return(_httpContextFactory?.Create(contextFeatures) ?? new DefaultHttpContext(contextFeatures));
}
