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(); } }