static void Main(string[] args) {
var appBuilder = new AppBuilder();
Nowin.OwinServerFactory.Initialize(appBuilder.Properties);
appBuilder.Use<ConsoleLogMiddleware>();
appBuilder.Use<SimpleStaticFileMiddleWare>(System.IO.Path.Combine(Environment.CurrentDirectory, @"../../www"));
var startup = new WebApi.Startup();
startup.Configuration(appBuilder);
var builder = new Nowin.ServerBuilder();
const string ip = "127.0.0.1";
const int port = 8888;
builder.SetAddress(System.Net.IPAddress.Parse(ip)).SetPort(port)
.SetOwinApp(appBuilder.Build())
.SetOwinCapabilities((IDictionary<string, object>)appBuilder.Properties[Nowin.OwinKeys.ServerCapabilitiesKey]);
using (var server = builder.Build()) {
var serverRef = new WeakReference<Nowin.INowinServer>(server);
Task.Run(() => {
Nowin.INowinServer nowinServer;
if (serverRef.TryGetTarget(out nowinServer)) {
nowinServer.Start();
}
});
var baseAddress = "http://" + ip + ":" + port + "/";
Console.WriteLine("Nowin server listening {0}, press ENTER to exit.", baseAddress);
Console.ReadLine();
}
}
public static IAppBuilder Create(IdentityServerBearerTokenAuthenticationOptions options)
{
IAppBuilder app = new AppBuilder();
app.SetLoggerFactory(new DiagnosticsLoggerFactory());
app.UseIdentityServerBearerTokenAuthentication(options);
app.Use((context, next) =>
{
var user = context.Authentication.User;
if (user == null ||
user.Identity == null ||
!user.Identity.IsAuthenticated)
{
context.Response.StatusCode = 401;
}
else
{
context.Response.StatusCode = 200;
}
return Task.FromResult(0);
});
return app;
}
public async Task When_host_Nancy_via_IAppBuilder_should_read_X509Certificate2()
{
// Given
var app = new AppBuilder();
var bootstrapper = new ConfigurableBootstrapper(config => config.Module<TestModule>());
var cert = @"-----BEGIN CERTIFICATE-----
MIICNTCCAZ4CCQC21XwOAYG32zANBgkqhkiG9w0BAQUFADBfMQswCQYDVQQGEwJH
QjETMBEGA1UECBMKU29tZS1TdGF0ZTEOMAwGA1UEChMFTmFuY3kxDjAMBgNVBAsT
BU5hbmN5MRswGQYDVQQDExJodHRwOi8vbmFuY3lmeC5vcmcwHhcNMTYwMjIyMTE1
NzQ3WhcNMTcwMjIxMTE1NzQ3WjBfMQswCQYDVQQGEwJHQjETMBEGA1UECBMKU29t
ZS1TdGF0ZTEOMAwGA1UEChMFTmFuY3kxDjAMBgNVBAsTBU5hbmN5MRswGQYDVQQD
ExJodHRwOi8vbmFuY3lmeC5vcmcwgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGB
AMT4vOtIH9Fzad+8KCGjMPkkVpCtn+L5H97bnI3x+y3x5lY0WRsK8FyxVshY/7fv
TDeeVKUWanmbMkQjgFRYffA3ep3/AIguswYdANiNVHrx0L7DXNDcgsjRwaa6JVgQ
9iavlli0a80AF67FN1wfidlHCX53u3/fAjiSTwf7D+NBAgMBAAEwDQYJKoZIhvcN
AQEFBQADgYEAh12A4NntHHdVMGaw+2umXkWqCOyAPuNhyBGUHK5vGON+VG0HPFaf
8P8eMtdF4deBHkrfoWxRuGGn2tJzNpZLiEf23BAivEf36IqwfkVP7/zDwI+bjVXC
k64Un2uN8ALR/wLwfJzHfOLPtsca7ySWhlv8oZo2nk0vR34asQiGJDQ=
-----END CERTIFICATE-----
";
var embeddedCert = Encoding.UTF8.GetBytes(cert);
app.Use(new Func<AppFunc, AppFunc>(next => (async env =>
{
env.Add("ssl.ClientCertificate", new X509Certificate(embeddedCert));
await next.Invoke(env);
})));
app.UseNancy(opts =>
{
opts.Bootstrapper = bootstrapper;
opts.EnableClientCertificates = true;
});
var appFunc = app.Build();
var handler = new OwinHttpMessageHandler(appFunc);
using (var httpClient = new HttpClient(handler)
{
BaseAddress = new Uri("http://localhost")
})
{
// When
var response = await httpClient.GetAsync(new Uri("http://localhost/ssl"));
// Then
Assert.Equal(System.Net.HttpStatusCode.OK, response.StatusCode);
}
}
private void ConfigurePipeline(AppFunc next, string fullPath)
{
Console.WriteLine("Configuring pipeline...");
try
{
string index = string.Format(
"<HTML><HEAD><TITLE>Dynamic Middleware</TITLE></HEAD><BODY><p>Edit {0} and refresh to see below links change.</p>",
fullPath);
var allLines = File.ReadAllLines(fullPath);
var app = new AppBuilder();
foreach(var line in allLines)
{
var paths = line.Split(';');
app.UseDirectoryBrowser(new DirectoryBrowserOptions
{
RequestPath = new PathString(paths[0]),
FileSystem = new PhysicalFileSystem(paths[1])
});
index += string.Format("<a href='{0}'>{0}</a><br>", paths[0]);
Console.WriteLine("Directory {0} on {1}", paths[1], paths[0]);
}
app.Use(async (ctx, next2) =>
{
if(ctx.Request.Path.Value == "/")
{
await ctx.Response.WriteAsync(index);
}
await next2();
});
app.Run(ctx => next(ctx.Environment));
_dynamicAppFunc = app.Build();
}
catch(Exception ex)
{
Console.WriteLine(ex);
_dynamicAppFunc = async env =>
{
var context = new OwinContext(env);
context.Response.StatusCode = 500;
context.Response.ReasonPhrase = "Internal server error";
await context.Response.WriteAsync(ex.Message);
};
}
}
public void SendAsync_Preflight_ReturnsAllowMethodsAndAllowHeaders(string policyOrigin, string requestedMethod, string expectedOrigin, string requestedHeaders)
{
IAppBuilder builder = new AppBuilder();
var policy = new CorsPolicy
{
AllowAnyHeader = true,
AllowAnyMethod = true
};
if (policyOrigin == "*")
{
policy.AllowAnyOrigin = true;
}
else
{
foreach (var o in policyOrigin.Split(','))
{
policy.Origins.Add(o.Trim());
}
}
builder.UseCors(new CorsOptions
{
PolicyProvider = new CorsPolicyProvider
{
PolicyResolver = context => Task.FromResult(policy)
}
});
builder.Use((context, next) => Task.FromResult<object>(null));
var app = (AppFunc)builder.Build(typeof(AppFunc));
IOwinRequest request = CreateRequest("http://localhost/sample");
request.Method = "OPTIONS";
request.Headers.Set(CorsConstants.Origin, "http://localhost");
request.Headers.Set(CorsConstants.AccessControlRequestMethod, requestedMethod);
request.Headers.Set(CorsConstants.AccessControlRequestHeaders, requestedHeaders);
app(request.Environment).Wait();
var response = new OwinResponse(request.Environment);
string origin = response.Headers.Get(CorsConstants.AccessControlAllowOrigin);
string allowMethod = response.Headers.Get(CorsConstants.AccessControlAllowMethods);
string[] allowHeaders = response.Headers.Get(CorsConstants.AccessControlAllowHeaders).Split(',');
string[] requestedHeaderArray = requestedHeaders.Split(',');
Assert.Equal(200, response.StatusCode);
Assert.Equal(expectedOrigin, origin);
Assert.Equal(requestedMethod, allowMethod);
foreach (var requestedHeader in requestedHeaderArray)
{
Assert.Contains(requestedHeader, allowHeaders);
}
request = CreateRequest("http://localhost/sample");
request.Method = requestedMethod;
request.Headers.Set(CorsConstants.Origin, "http://localhost");
foreach (var requestedHeader in requestedHeaderArray)
{
request.Headers.Set(requestedHeader, requestedHeader);
}
app(request.Environment).Wait();
response = new OwinResponse(request.Environment);
Assert.Equal(200, response.StatusCode);
Assert.Equal(expectedOrigin, origin);
}
public void SendAsync_ReturnsAllowAOrigin(string requestOrigin, string policyOrigin, string expectedOrigin)
{
IAppBuilder builder = new AppBuilder();
var policy = new CorsPolicy();
if (policyOrigin == "*")
{
policy.AllowAnyOrigin = true;
}
else
{
foreach (var o in policyOrigin.Split(','))
{
policy.Origins.Add(o.Trim());
}
}
builder.UseCors(new CorsOptions
{
PolicyProvider = new CorsPolicyProvider
{
PolicyResolver = context => Task.FromResult(policy)
}
});
builder.Use((context, next) => Task.FromResult<object>(null));
var app = (AppFunc)builder.Build(typeof(AppFunc));
IOwinRequest request = CreateRequest("http://localhost/sample");
if ("header_not_set" != requestOrigin)
{
request.Headers.Set(CorsConstants.Origin, requestOrigin);
}
app(request.Environment).Wait();
var response = new OwinResponse(request.Environment);
string origin = response.Headers.Get("Access-Control-Allow-Origin");
Assert.Equal(200, response.StatusCode);
Assert.Equal(expectedOrigin, origin);
}
private static void Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.WriteTo
.Console()
.MinimumLevel.Verbose()
.CreateLogger();
var app = new AppBuilder();
app.MaxUrlLength(100);
app.MaxQueryStringLength(80);
app.MaxConcurrentRequests(4);
app.MinResponseDelay(context =>
{
var queryParams = HttpUtility.ParseQueryString(context.Uri.Query);
var minResponseDelayParam = queryParams.Get("minresponsedelay");
int minResponseDelay;
return int.TryParse(minResponseDelayParam, out minResponseDelay)
? TimeSpan.FromSeconds(minResponseDelay)
: TimeSpan.Zero;
});
app.MaxBandwidthPerRequest(context =>
{
var queryParams = HttpUtility.ParseQueryString(context.Uri.Query);
var maxBandwidthParam = queryParams.Get("maxbandwidthperrequest");
int maxBandwidth;
return int.TryParse(maxBandwidthParam, out maxBandwidth)
? maxBandwidth
: -1;
});
app.MaxBandwidthGlobal(10 * 1024 * 1024);
app.Use(async (context, next) =>
{
if(!context.Request.Uri.AbsolutePath.Equals("/file", StringComparison.OrdinalIgnoreCase))
{
await next();
return;
}
int size;
if(!int.TryParse(context.Request.Query.Get("size"), out size))
{
await next();
return;
}
context.Response.ContentLength = size;
context.Response.ContentType = "application/octect-stream";
context.Response.StatusCode = 200;
context.Response.ReasonPhrase = "OK";
var buffer = new byte[16384];
int count = 0;
while(count < size)
{
int length = Math.Min(buffer.Length, size - count);
await context.Response.WriteAsync(buffer, 0, length, context.Request.CallCancelled);
count += length;
}
});
app.Use(async (context, next) =>
{
context.Response.ContentType = "text/html";
context.Response.StatusCode = 200;
context.Response.ReasonPhrase = "OK";
var index = File.ReadAllText("index.html");
await context.Response.WriteAsync(index);
});
var server = ServerBuilder.New()
.SetEndPoint(new IPEndPoint(IPAddress.Loopback, 8080))
.SetOwinApp(app.Build());
using(server.Build())
{
server.Start();
Process.Start("http://localhost:8080");
Log.Information("Server running http://localhost:8080");
Console.ReadLine();
}
}
