public void Body_WithSingletonControllerInstance_Fails()
{
// Arrange
HttpClient httpClient = new HttpClient();
string baseAddress = "http://localhost";
string requestUri = baseAddress + "/Test";
HttpSelfHostConfiguration configuration = new HttpSelfHostConfiguration(baseAddress);
configuration.Routes.MapHttpRoute("Default", "{controller}", new { controller = "Test" });
configuration.ServiceResolver.SetService(typeof(IHttpControllerFactory), new MySingletonControllerFactory());
HttpSelfHostServer host = new HttpSelfHostServer(configuration);
host.OpenAsync().Wait();
HttpResponseMessage response = null;
try
{
// Act
response = httpClient.GetAsync(requestUri).Result;
response = httpClient.GetAsync(requestUri).Result;
response = httpClient.GetAsync(requestUri).Result;
// Assert
Assert.Equal(HttpStatusCode.InternalServerError, response.StatusCode);
}
finally
{
if (response != null)
{
response.Dispose();
}
}
host.CloseAsync().Wait();
}
/// <summary>
/// The program main method
/// </summary>
/// <param name="args">The program arguments</param>
private static void Main(string[] args)
{
var config = new HttpSelfHostConfiguration(ServiceAddress);
config.MapHttpAttributeRoutes();
config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("application/json"));
config.EnableCors(new EnableCorsAttribute("*", "*", "*"));
using (var server = new HttpSelfHostServer(config)) {
try {
server.OpenAsync().Wait();
Console.WriteLine("Service running on " + ServiceAddress + ". Press enter to quit.");
Console.ReadLine();
}
catch (Exception e) {
if (!IsAdministrator()) {
Console.WriteLine("Please restart as admin.");
Debug.WriteLine("Restart Visual Studio as admin");
}
else {
Console.WriteLine("Server failed to start.");
}
Console.ReadLine();
}
}
}
static void Main(string[] args)
{
var baseurl = new Uri("http://localhost:9000/");
var config = new HttpSelfHostConfiguration(baseurl);
//config.MessageHandlers.Add(new GitHubApiRouter(baseurl));
//config.Routes.Add("default", new TreeRoute("",new TreeRoute("home").To<HomeController>(),
// new TreeRoute("contact",
// new TreeRoute("{id}",
// new TreeRoute("address",
// new TreeRoute("{addressid}").To<ContactAddressController>())
// ).To<ContactController>())
// )
// );
var route = new TreeRoute("api");
route.AddWithPath("home", r => r.To<HomeController>());
route.AddWithPath("contact/{id}",r => r.To<ContactController>());
route.AddWithPath("contact/{id}/adddress/{addressid}", r => r.To<ContactAddressController>());
route.AddWithPath("act/A", r => r.To<ActionController>().ToAction("A"));
route.AddWithPath("act/B", r => r.To<ActionController>().ToAction("B"));
config.Routes.Add("default", route);
var host = new HttpSelfHostServer(config);
host.OpenAsync().Wait();
Console.WriteLine("Host open. Hit enter to exit...");
Console.Read();
host.CloseAsync().Wait();
}
public WebApiTest()
{
IOExtensions.DeleteDirectory("Test");
NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(19079);
Task.Factory.StartNew(() => // initialize in MTA thread
{
config = new HttpSelfHostConfiguration(Url)
{
MaxReceivedMessageSize = Int64.MaxValue,
TransferMode = TransferMode.Streamed
};
var configuration = new InMemoryConfiguration();
configuration.Initialize();
configuration.DataDirectory = "~/Test";
ravenFileSystem = new RavenFileSystem(configuration);
ravenFileSystem.Start(config);
})
.Wait();
server = new HttpSelfHostServer(config);
server.OpenAsync().Wait();
WebClient = new WebClient
{
BaseAddress = Url
};
}
public void Start()
{
using (var server = new HttpSelfHostServer(_httpSelfHostConfigurationWrapper.Create()))
{
server.OpenAsync().Wait();
}
}
static void Main(string[] args)
{
var address = "http://localhost:900";
var config = new HttpSelfHostConfiguration(address);
config.MapHttpAttributeRoutes();
using (var server = new HttpSelfHostServer(config))
{
server.OpenAsync().Wait();
Console.WriteLine("Server running at {0}. Press any key to exit", address);
var client = new HttpClient() {BaseAddress = new Uri(address)};
var persons = client.GetAsync("person").Result;
Console.WriteLine(persons.Content.ReadAsStringAsync().Result);
var newPerson = new Person {Id = 3, Name = "Luiz"};
var response = client.PostAsJsonAsync("person", newPerson).Result;
if (response.IsSuccessStatusCode)
{
var person3 = client.GetAsync("person/3").Result;
Console.WriteLine(person3.Content.ReadAsStringAsync().Result);
}
Console.ReadLine();
}
}
public static HttpSelfHostServer OpenConfiguredServiceHost(this CommandsController @this, string url)
{
var config = ZazServer.ConfigureAsSelfHosted(url);
var host = new HttpSelfHostServer(config);
host.OpenAsync().Wait();
return host;
}
public void Given_command_server_runnig()
{
var config = ZazServer.ConfigureAsSelfHosted(URL, new ServerConfiguration
{
Registry = new FooCommandRegistry(),
Broker = new DelegatingCommandBroker((cmd, ctx) =>
{
throw new InvalidOperationException("Server failed...");
// return Task.Factory.StartNew(() => { });
})
});
using (var host = new HttpSelfHostServer(config))
{
host.OpenAsync().Wait();
// Client side
var bus = new ZazClient(URL);
try
{
bus.PostAsync(new FooCommand
{
Message = "Hello world"
}).Wait();
}
catch (Exception ex)
{
_resultEx = ex;
}
}
}
public void Setup()
{
var path = Environment.CurrentDirectory.Replace(@"bin\Debug", "");
zipFilepath = path + "ExampleZip.zip";
var application = new BootStrapApplication();
server = application.ConfigureServer();
}
public void SetUp()
{
var config = new HttpSelfHostConfiguration(URL);
ZazServer.Configure(config, Prefix1, new ServerConfiguration
{
Registry = new FooCommandRegistry(),
Broker = new DelegatingCommandBroker((o, context) =>
{
_api1Command = (FooCommand)o;
return Task.Factory.StartNew(() => { });
}),
});
ZazServer.Configure(config, Prefix2, new ServerConfiguration
{
Registry = new FooCommandRegistry(),
Broker = new DelegatingCommandBroker((o, context) =>
{
_api2Command = (FooCommand)o;
return Task.Factory.StartNew(() => { });
}),
});
_host = new HttpSelfHostServer(config);
_host.OpenAsync().Wait();
}
public bool Initialize()
{
var principal = GetPrincipalIdentity();
if(principal == null)
{
return false;
}
/* -> Belongs in a separate execution context (using scope for ACL executions)
var admin = principal.IsInRole(WindowsBuiltInRole.Administrator);
if (!admin)
{
Console.WriteLine("API startup requires administrator privileges.");
return false;
}
_username = principal.Identity.Name;
*/
Port = ConfigurationManager.AppSettings["ServicePort"] ?? "8181";
Machine = Environment.MachineName;
BaseAddress = String.Concat("http://", Machine, ":", Port, "/");
Thread.CurrentPrincipal = principal;
var host = ConfigureSelfHost();
Configuration = host;
_server = new HttpSelfHostServer(host);
CohortApi.Register(Configuration);
return true;
}
public static HttpStatusCode SendJsonGetCode(string routeTemp, string uri, string json)
{
HttpStatusCode actualHttpCode;
HttpSelfHostConfiguration config
= new HttpSelfHostConfiguration("http://localhost/");
config.Routes.MapHttpRoute(
name: "Default",
routeTemplate: routeTemp
);
using (HttpSelfHostServer server = new HttpSelfHostServer(config))
using (HttpClient client = getJsonClient())
{
server.OpenAsync().Wait();
using (HttpRequestMessage request =
getJsonRequest(HttpMethod.Post, uri, json))
using (HttpResponseMessage response = client.SendAsync(request).Result)
{
actualHttpCode = response.StatusCode;
}
server.CloseAsync().Wait();
}
return actualHttpCode;
}
static void Main(string[] args)
{
// run as administrator: netsh http add urlacl url=http://+:56473/ user=machine\username
// http://www.asp.net/web-api/overview/older-versions/self-host-a-web-api
var config = new HttpSelfHostConfiguration("http://localhost:56473");
config.Routes.MapHttpRoute("Default", "{controller}.json");
config.Formatters.Remove(config.Formatters.XmlFormatter);
config.Formatters.JsonFormatter.SerializerSettings.Converters.Add(
new Newtonsoft.Json.Converters.StringEnumConverter());
config.Formatters.JsonFormatter.SerializerSettings.Converters.Add(
new Newtonsoft.Json.Converters.IsoDateTimeConverter { DateTimeFormat = "yyyy-MM-dd HH:mm" });
using (HttpSelfHostServer server = new HttpSelfHostServer(config))
{
server.OpenAsync().Wait();
Console.WriteLine("Press Enter to quit...");
Console.ReadLine();
}
}
public override void Init()
{
var actions = new HttpMethodCollection();
foreach (var action in RequestReceived)
{
actions.RegisterMethod(action.Metadata, action.Value);
}
var config = new HttpSelfHostConfiguration(BASE_URL_HTTP)
{
DependencyResolver = new DependencyResolver(actions, Logger)
};
config.Routes.MapHttpRoute(
"API Default", "api/{pluginName}/{methodName}/{callback}",
new
{
controller = "Common",
action = "Get",
callback = RouteParameter.Optional
})
.DataTokens["Namespaces"] = new[] {"ThinkingHome.Plugins.Listener.Api"};
server = new HttpSelfHostServer(config);
}
static void Main(string[] args)
{
var cfg = new HttpSelfHostConfiguration("http://localhost:1337");
cfg.MaxReceivedMessageSize = 16L * 1024 * 1024 * 1024;
cfg.TransferMode = TransferMode.StreamedRequest;
cfg.ReceiveTimeout = TimeSpan.FromMinutes(20);
cfg.Routes.MapHttpRoute(
"API Default", "api/{controller}/{id}",
new { id = RouteParameter.Optional });
cfg.Routes.MapHttpRoute(
"Default", "{*res}",
new { controller = "StaticFile", res = RouteParameter.Optional });
var db = new EmbeddableDocumentStore { DataDirectory = new FileInfo("db/").DirectoryName };
db.Initialize();
cfg.Filters.Add(new RavenDbApiAttribute(db));
using (HttpSelfHostServer server = new HttpSelfHostServer(cfg))
{
Console.WriteLine("Initializing server.");
server.OpenAsync().Wait();
Console.WriteLine("Server ready at: " + cfg.BaseAddress);
Console.WriteLine("Press Enter to quit.");
Console.ReadLine();
}
}
static void Main(string[] args)
{
Configuration cfg = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None);
var selfConfig = cfg.GetSection("SeifConfiguration") as SeifConfiguration;
//var servConfig = new ProviderConfiguration();
//servConfig.ApiDomain = "api.aaa.com";
//servConfig.ApiIpAddress = "172.16.1.121";
//servConfig.SerializeMode = "ssjson";
//servConfig.Protocol = "Http";
//servConfig.AddtionalFields.Add(AttrKeys.ApiGetEntrance, "api/get");
//servConfig.AddtionalFields.Add(AttrKeys.ApiPostEntrance, "api/post");
//var clientConfig = new ConsumerConfiguration();
//var registryProvider = new RedisRegistryProvider();
//var registry = new GenericRegistry(registryProvider, registryProvider);
//var typeBuilder = new AutofacTypeBuilder();
////SeifApplication.Initialize(registry, servConfig, clientConfig, typeBuilder, new ISerializer[]{new ServiceStackJsonSerializer()});
SeifApplication.Initialize(selfConfig);
SeifApplication.ExposeService<IDemoService, DemoService>();
//SeifApplication.ReferenceService<IEchoService>(new ProxyOptions(), new IInvokeFilter[0]);
SeifApplication.AppEnv.TypeBuilder.Build();
var config = new HttpSelfHostConfiguration("http://localhost:3333");
config.Filters.Add(new ExceptionFilter());
config.Routes.MapHttpRoute("default", "api/{controller}/{action}/{id}", new { id = RouteParameter.Optional });
var server = new HttpSelfHostServer(config);
server.OpenAsync().Wait();
Console.WriteLine("Server is opened");
Console.Read();
}
public void Given_command_server_runnig()
{
var config = ZazServer.ConfigureAsSelfHosted(URL);
_host = new HttpSelfHostServer(config);
_host.OpenAsync().Wait();
}
static void Main(string[] args)
{
const string address = "http://localhost:8080";
var config = new HttpSelfHostConfiguration(address);
config.Formatters.Insert(0, new AssetFormatter());
config.Routes.MapHttpRoute(
"Admin Web", "admin", new { controller = "Admin" }
);
config.Routes.MapHttpRoute(
"Assets", "assets/{type}/{asset}", new { controller = "Assets" }
);
config.Routes.MapHttpRoute(
"API Default", "api/{controller}/{id}", new { id = RouteParameter.Optional }
);
using (var server = new HttpSelfHostServer(config))
{
server.OpenAsync().Wait();
Console.WriteLine("Started host on " + address + "/admin/");
Console.WriteLine("Press Enter to quit.");
Console.ReadLine();
}
}
public SampleService(bool throwOnStart, bool throwOnStop, bool throwUnhandled, Uri address)
{
_throwOnStart = throwOnStart;
_throwOnStop = throwOnStop;
_throwUnhandled = throwUnhandled;
if (!EventLog.SourceExists(EventSource))
{
EventLog.CreateEventSource(EventSource, "Application");
}
EventLog.WriteEntry(EventSource,
String.Format("Creating server at {0}",
address.ToString()));
_config = new HttpSelfHostConfiguration(address);
_config.Routes.MapHttpRoute("DefaultApi",
"api/{controller}/{id}",
new { id = RouteParameter.Optional }
);
_config.Routes.MapHttpRoute(
"Default", "{controller}/{action}",
new { controller = "Home", action = "Index", date = RouteParameter.Optional});
const string viewPathTemplate = "SampleTopshelfService.Views.{0}";
var templateConfig = new TemplateServiceConfiguration();
templateConfig.Resolver = new DelegateTemplateResolver(name =>
{
string resourcePath = string.Format(viewPathTemplate, name);
var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(resourcePath);
using (var reader = new StreamReader(stream))
{
return reader.ReadToEnd();
}
});
Razor.SetTemplateService(new TemplateService(templateConfig));
_server = new HttpSelfHostServer(_config);
}
public static HttpClient CreateHttpClient()
{
var baseAddress = new Uri("http://localhost:8080");
var config = new HttpSelfHostConfiguration(baseAddress);
// ?
Setup.Configure(config);
var server = new HttpSelfHostServer(config);
var client = new HttpClient(server); // <--- MAGIC!
try
{
client.BaseAddress = baseAddress;
return client;
}
catch
{
client.Dispose();
throw;
}
}
public void Start()
{
selfHostServer = new HttpSelfHostServer(httpSelfHostConfiguration);
selfHostServer.OpenAsync();
Logger.Info("Started management app host");
}
public static JObject SendJsonGetJson(HttpMethod method, string routeTemp, string uri, string json)
{
JObject result;
HttpSelfHostConfiguration config
= new HttpSelfHostConfiguration("http://localhost/");
config.Routes.MapHttpRoute(
name: "Default",
routeTemplate: routeTemp
);
using (HttpSelfHostServer server = new HttpSelfHostServer(config))
using (HttpClient client = getJsonClient())
{
server.OpenAsync().Wait();
using (HttpRequestMessage request =
getJsonRequest(method, uri, json))
using (HttpResponseMessage response = client.SendAsync(request).Result)
{
string responseJson = response.Content.ReadAsStringAsync().Result;
result = JObject.Parse(responseJson);
}
server.CloseAsync().Wait();
}
return result;
}
public HttpSelfHostServer Build()
{
var log = HostLogger.Get(typeof(WebApiConfigurator));
var baseAddress = new UriBuilder(Scheme, Domain, Port).Uri;
log.Debug(string.Format("[Topshelf.WebApi] Configuring WebAPI Selfhost for URI: {0}", baseAddress));
var config = new HttpSelfHostConfiguration(baseAddress);
if(DependencyResolver != null)
config.DependencyResolver = DependencyResolver;
if (ServerConfigurer != null)
{
ServerConfigurer(config);
}
if (RouteConfigurer != null)
{
RouteConfigurer(config.Routes);
}
Server = new HttpSelfHostServer(config);
log.Info(string.Format("[Topshelf.WebApi] WebAPI Selfhost server configurated and listening on: {0}", baseAddress));
return Server;
}
static void Main(string[] args)
{
// classic
var config = new HttpSelfHostConfiguration("http://localhost:18081");
// HTTPS
//var config = new HttpsSelfHostConfiguration("http://localhost:18081");
// NTLM
//var config = new NtlmHttpSelfHostConfiguration("http://localhost:18081");
// BASIC AUTHENTICATION
//var config = new BasicAuthenticationSelfHostConfiguration("http://localhost:18081",
// (un, pwd) => un == "johndoe" && pwd == "123456");
config.Routes.MapHttpRoute(
"API Default", "api/{controller}/{id}",
new { id = RouteParameter.Optional });
using (var server = new HttpSelfHostServer(config))
{
server.OpenAsync().Wait();
Console.WriteLine("Press Enter to quit.");
Console.ReadLine();
}
}
public void Start()
{
Log.Info("Starting");
Server = new HttpSelfHostServer(Config);
Server.OpenAsync().Wait();
Log.Info("Started");
}
static void Main(string[] args)
{
Assembly.Load("WebApi, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null");
HttpSelfHostConfiguration configuration = new HttpSelfHostConfiguration("http://localhost/selfhost/tyz");//指定基地址
try
{
using (HttpSelfHostServer httpServer = new HttpSelfHostServer(configuration))
{
httpServer.Configuration.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional });
httpServer.OpenAsync().Wait();
Console.Read();
}
}
catch (Exception e)
{
}
////web API的SelfHost寄宿方式通过HttpSelfHostServer来完成
//using (HttpSelfHostServer httpServer = new HttpSelfHostServer(configuration))
//{
// httpServer.Configuration.Routes.MapHttpRoute(
// name: "DefaultApi",
// routeTemplate: "api/{controller}/{id}",
// defaults: new { id = RouteParameter.Optional });
// httpServer.OpenAsync();//开启后，服务器开始监听来自网络的调用请求
// Console.Read();
//}
}
static void Main(string[] args)
{
var config = new HttpSelfHostConfiguration("http://localhost:8080");
// Attribute Routing
config.Routes.MapHttpAttributeRoutes(cfg =>
{
cfg.ScanAssemblyOf<ProductsController>();
// Must have this on, otherwise you need to specify RouteName in your attributes
cfg.AutoGenerateRouteNames = true;
});
using (var server = new HttpSelfHostServer(config))
{
server.OpenAsync().Wait();
Console.WriteLine("Routes:");
config.Routes.Cast<HttpRoute>().LogTo(Console.Out);
Console.WriteLine("Routes:");
Console.WriteLine("Press Enter to quit.");
Console.ReadLine();
}
}
static void Main(string[] args)
{
//var config = new HttpSelfHostConfiguration("http://localhost:8999");
var config = new MyConfig("http://localhost:8999");
config.Routes.MapHttpRoute(
"DefaultRoute", "{controller}/{id}",
new { id = RouteParameter.Optional });
//custom message processing
//var server = new HttpSelfHostServer(config,
// new MyNewSimpleMessagehandler());
//controller message processing
var server = new HttpSelfHostServer(config,
new MyNewSimpleMessagehandler());
server.OpenAsync();
//trick, calls server just created to confirm it works
var client = new HttpClient(server);
client.GetAsync("http://localhost:8999/simple")
.ContinueWith((t) =>
{
var result = t.Result;
result.Content.ReadAsStringAsync()
.ContinueWith((rt) => {
Console.WriteLine("Client got " + rt.Result);
});
});
//
Console.WriteLine("opening web api selfhost ");
Console.ReadKey();
}
static void Main(string[] args)
{
var config = new HttpSelfHostConfiguration("http://localhost:8999");
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
// using asp.net like hosting
// HttpSelfHostServer is using a different constructor compared to the previous project (SelfHost1)
var server = new HttpSelfHostServer(config);
var task = server.OpenAsync();
task.Wait();
Console.WriteLine("Server is up and running");
Console.WriteLine("Hit enter to call server with client");
Console.ReadLine();
// HttpSelfHostServer, derives from HttpMessageHandler => multiple level of inheritance
var client = new HttpClient(server);
client.GetAsync("http://localhost:8999/api/my").ContinueWith(t =>
{
var result = t.Result;
result.Content.ReadAsStringAsync()
.ContinueWith(rt =>
{
Console.WriteLine("client got response" + rt.Result);
});
});
Console.ReadLine();
}
public void SendAsync_Direct_Returns_OK_For_Successful_Stream_Write(string uri, TransferMode transferMode)
{
using (var port = new PortReserver())
{
// Arrange & Act
server = CreateServer(port, transferMode);
HttpResponseMessage response = new HttpClient(server).GetAsync(BaseUri(port, transferMode) + uri).Result;
string responseString = response.Content.ReadAsStringAsync().Result;
IEnumerable <string> headerValues = null;
bool isChunked = response.Headers.TryGetValues("Transfer-Encoding", out headerValues) && headerValues != null &&
headerValues.Any((v) => String.Equals(v, "chunked", StringComparison.OrdinalIgnoreCase));
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal("echoStream", responseString);
Assert.False(isChunked); // stream never chunk, buffered or streamed
}
}
private void SetupHost()
{
baseAddress = String.Format("http://localhost/");
HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(baseAddress);
config.HostNameComparisonMode = HostNameComparisonMode.Exact;
config.Routes.MapHttpRoute(
"Default",
"{controller}/{action}",
new { controller = "DeepNestedType" }
);
server = new HttpSelfHostServer(config);
httpClient = new HttpClient(server);
}
public SelfHostTester()
{
HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(_testPort.BaseUri);
BaseAddress = _testPort.BaseUri;
config.HostNameComparisonMode = HostNameComparisonMode.Exact;
config.Routes.MapHttpRoute("Default", "{controller}/{action}", new { controller = "NullResponse" });
MessageHandler = new NullResponseMessageHandler();
config.MessageHandlers.Add(MessageHandler);
_server = new HttpSelfHostServer(config);
_server.OpenAsync().Wait();
HttpClient = new HttpClient();
}
private static void CloseListenerComplete(IAsyncResult result)
{
HttpSelfHostServer server = (HttpSelfHostServer)result.AsyncState;
Contract.Assert(server != null);
Contract.Assert(server._listener != null);
try
{
server._listener.EndClose(result);
}
catch { }
finally
{
CloseNextChannel(server);
}
}
public void SetupHost()
{
baseAddress = String.Format("http://localhost:{0}/", HttpSelfHostServerTest.TestPort);
HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(baseAddress);
config.HostNameComparisonMode = HostNameComparisonMode.Exact;
config.Routes.MapHttpRoute("Default", "{controller}/{action}", new { controller = "NullResponse" });
messageHandler = new NullResponseMessageHandler();
config.MessageHandlers.Add(messageHandler);
server = new HttpSelfHostServer(config);
server.OpenAsync().Wait();
httpClient = new HttpClient();
}
public void SendAsync_ServiceModel_Returns_OK_For_Successful_ObjectContent_Write(string uri, TransferMode transferMode)
{
// Arrange
server = CreateServer(transferMode);
bool shouldChunk = transferMode == TransferMode.Streamed;
// Act
HttpResponseMessage response = new HttpClient().GetAsync(BaseUri(transferMode) + uri).Result;
string responseString = response.Content.ReadAsStringAsync().Result;
IEnumerable <string> headerValues = null;
bool isChunked = response.Headers.TryGetValues("Transfer-Encoding", out headerValues) && headerValues != null &&
headerValues.Any((v) => String.Equals(v, "chunked", StringComparison.OrdinalIgnoreCase));
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal("\"echoString\"", responseString);
Assert.Equal(shouldChunk, isChunked);
}
public async Task Get_Returns_Hard404_If_IgnoreRoute(string uri, TransferMode transferMode)
{
using (var port = new PortReserver())
{
// Arrange & Act
server = await CreateServerAsync(port, transferMode, ignoreRoute : true);
HttpResponseMessage response = await new HttpClient().GetAsync(
BaseUri(port, transferMode) + uri
);
// Assert
Assert.Equal(HttpStatusCode.NotFound, response.StatusCode);
Assert.False(
response.RequestMessage.Properties.ContainsKey(HttpPropertyKeys.NoRouteMatched)
);
}
}
public async Task SendAsync_ServiceModel_Closes_Connection_When_ObjectContent_CopyToAsync_Throws(
string uri,
TransferMode transferMode
)
{
using (var port = new PortReserver())
{
// Arrange
server = await CreateServerAsync(port, transferMode);
Task <HttpResponseMessage> task = new HttpClient().GetAsync(
BaseUri(port, transferMode) + uri
);
// Act & Assert
await Assert.ThrowsAsync <HttpRequestException>(() => task);
}
}
private static void OpenListenerComplete(IAsyncResult result)
{
HttpSelfHostServer server = (HttpSelfHostServer)result.AsyncState;
Contract.Assert(server != null);
Contract.Assert(server._listener != null);
try
{
server._listener.EndOpen(result);
// Start accepting channel
BeginAcceptChannel(server);
}
catch (Exception e)
{
FaultTask(server._openTaskCompletionSource, e);
}
}
private void BeginOpenListener(HttpSelfHostServer server)
{
Contract.Assert(server != null);
try
{
// Create WCF HTTP transport channel
HttpBinding binding = new HttpBinding();
// Get it configured
BindingParameterCollection bindingParameters =
server._configuration.ConfigureBinding(binding);
if (bindingParameters == null)
{
bindingParameters = new BindingParameterCollection();
}
// Build channel listener
server._listener = binding.BuildChannelListener <IReplyChannel>(
server._configuration.BaseAddress,
bindingParameters
);
if (server._listener == null)
{
throw Error.InvalidOperation(
SRResources.InvalidChannelListener,
typeof(IChannelListener).Name,
typeof(IReplyChannel).Name
);
}
IAsyncResult result = server._listener.BeginOpen(_onOpenListenerComplete, server);
if (result.CompletedSynchronously)
{
OpenListenerComplete(result);
}
}
catch (Exception e)
{
FaultTask(server._openTaskCompletionSource, e);
}
}
public async Task Get_Returns_Success_If_OtherRouteMatched(
string uri,
TransferMode transferMode
)
{
using (var port = new PortReserver())
{
// Arrange & Act
server = await CreateServerAsync(port, transferMode, ignoreRoute : true);
HttpResponseMessage response = await new HttpClient().GetAsync(
BaseUri(port, transferMode) + uri
);
string responseString = await response.Content.ReadAsStringAsync();
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal("\"echoString\"", responseString);
}
}
public async Task Get_Returns_Value_If_IgnoreRoute_WithConstraints_ConstraintsNotMatched(
string uri,
TransferMode transferMode
)
{
using (var port = new PortReserver())
{
// Arrange & Act
server = await CreateServerAsync(port, transferMode, ignoreRoute : true);
HttpResponseMessage response = await new HttpClient().GetAsync(
BaseUri(port, transferMode) + uri
);
string responseString = await response.Content.ReadAsStringAsync();
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(String.Concat("/constraint/values/", responseString), uri);
}
}
public async Task SendAsync_Direct_Returns_OK_For_Successful_ObjectContent_Write(
string uri,
TransferMode transferMode
)
{
using (var port = new PortReserver())
{
// Arrange & Act
server = await CreateServerAsync(port, transferMode);
HttpResponseMessage response = await new HttpClient().GetAsync(
BaseUri(port, transferMode) + uri
);
string responseString = await response.Content.ReadAsStringAsync();
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal("\"echoString\"", responseString);
}
}
private static async Task <HttpSelfHostServer> CreateServerAsync(PortReserver port, TransferMode transferMode, bool ignoreRoute = false)
{
HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(BaseUri(port, transferMode));
config.HostNameComparisonMode = HostNameComparisonMode.Exact;
if (ignoreRoute)
{
config.Routes.IgnoreRoute("Ignore", "{controller}/{action}");
config.Routes.IgnoreRoute("IgnoreWithConstraints", "constraint/values/{id}", constraints: new { constraint = new CustomConstraint() });
}
config.Routes.MapHttpRoute("Default", "{controller}/{action}");
config.Routes.MapHttpRoute("Other", "other/{controller}/{action}");
config.TransferMode = transferMode;
config.MapHttpAttributeRoutes();
HttpSelfHostServer server = new HttpSelfHostServer(config);
await server.OpenAsync();
return(server);
}
private static void BeginCloseListener(HttpSelfHostServer server)
{
Contract.Assert(server != null);
try
{
if (server._listener != null)
{
IAsyncResult result = server._listener.BeginClose(_onCloseListenerComplete, server);
if (result.CompletedSynchronously)
{
CloseListenerComplete(result);
}
}
}
catch
{
CloseNextChannel(server);
}
}
// HttpSelfHostServer has a small latency between CloseAsync.Wait
// completing and other async tasks still running. Theory driven
// tests run quickly enough they sometimes attempt to open when the
// prior test is still finishing those async tasks.
private static void SafeOpen(HttpSelfHostServer server)
{
for (int i = 0; i < 10; i++)
{
try
{
server.OpenAsync().Wait();
return;
}
catch (Exception)
{
if (i == 9)
{
System.Diagnostics.Debug.WriteLine("HttpSelfHostServerTests.SafeOpen failed to open server at " + server.Configuration.VirtualPathRoot);
throw;
}
Thread.Sleep(200);
}
}
}
private void SetupHosts()
{
try
{
HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(BaseUri(TransferMode.Buffered));
config.Routes.MapHttpRoute("Default", "{controller}/{action}");
_bufferServer = new HttpSelfHostServer(config);
SafeOpen(_bufferServer);
config = new HttpSelfHostConfiguration(BaseUri(TransferMode.Streamed));
config.Routes.MapHttpRoute("Default", "{controller}/{action}");
config.TransferMode = TransferMode.Streamed;
_streamServer = new HttpSelfHostServer(config);
SafeOpen(_streamServer);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine("HttpSelfHostServerTests.SetupHosts failed: " + ex.GetBaseException());
throw;
}
}
public async Task SendAsync_ServiceModel_AddsSelfHostHttpRequestContext()
{
// Arrange
using (PortReserver port = new PortReserver())
{
string baseUri = port.BaseUri;
HttpRequestContext context = null;
Uri via = null;
Func <HttpRequestMessage, CancellationToken, Task <HttpResponseMessage> > sendAsync = (
r,
c
) =>
{
if (r != null)
{
context = r.GetRequestContext();
}
SelfHostHttpRequestContext typedContext = context as SelfHostHttpRequestContext;
if (typedContext != null)
{
via = typedContext.RequestContext.RequestMessage.Properties.Via;
}
return(Task.FromResult(new HttpResponseMessage()));
};
using (
HttpSelfHostConfiguration expectedConfiguration = new HttpSelfHostConfiguration(
baseUri
)
)
{
expectedConfiguration.HostNameComparisonMode = HostNameComparisonMode.Exact;
using (HttpMessageHandler dispatcher = new LambdaHttpMessageHandler(sendAsync))
using (
HttpSelfHostServer server = new HttpSelfHostServer(
expectedConfiguration,
dispatcher
)
)
using (HttpClient client = new HttpClient())
using (
HttpRequestMessage expectedRequest = new HttpRequestMessage(
HttpMethod.Get,
baseUri
)
)
{
await server.OpenAsync();
// Act
using (HttpResponseMessage ignore = await client.SendAsync(expectedRequest))
{
// Assert
SelfHostHttpRequestContext typedContext =
(SelfHostHttpRequestContext)context;
Assert.Equal(expectedRequest.RequestUri, via);
Assert.Same(expectedConfiguration, context.Configuration);
Assert.Equal(
expectedRequest.RequestUri,
typedContext.Request.RequestUri
);
await server.CloseAsync();
}
}
}
}
}
public static void Main(string[] args)
{
var config = new HttpSelfHostConfiguration("http://127.0.0.1:3001");
config.MapHttpAttributeRoutes();
config.EnableCors();
config.Routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.Routes.MapHttpRoute(
name: "ReportsApi",
routeTemplate: "api/{controller}/{action}/{id}",
defaults: new { id = RouteParameter.Optional }
);
config.Formatters.JsonFormatter.SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/html"));
using (HttpSelfHostServer server = new HttpSelfHostServer(config))
{
server.OpenAsync().Wait();
Console.WriteLine("Press Enter to quit.");
Console.ReadLine();
}
}
