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(); }
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(); }
static void Main(string[] args) { HttpSelfHostServer server = null; try { // Set up server configuration HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(BaseAddress); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); // Create server server = new HttpSelfHostServer(config); // Start listening server.OpenAsync().Wait(); Console.WriteLine("Listening on " + BaseAddress); Console.ReadLine(); } catch (Exception e) { Console.WriteLine("Could not start server: {0}", e.GetBaseException().Message); Console.WriteLine("Hit ENTER to exit..."); Console.ReadLine(); } finally { if (server != null) { // Stop listening server.CloseAsync().Wait(); } } }
protected override void OnStart(string[] args) { Uri baseAddress = new Uri("http://" + ConfigurationManager.AppSettings["server"] + GetPort()); HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(baseAddress) { HostNameComparisonMode = HostNameComparisonMode.Exact }; string origins = ConfigurationManager.AppSettings["corsItems"]; if (string.IsNullOrEmpty(origins)) { origins = "*"; } config.EnableCors(new EnableCorsAttribute(origins, "*", "*")); var formatters = GlobalConfiguration.Configuration.Formatters; formatters.Remove(formatters.XmlFormatter); WebApiConfig.Register(config); config.MapHttpAttributeRoutes(); config.EnsureInitialized(); _server = new HttpSelfHostServer(config); // Start listening _server.OpenAsync().Wait(); System.Console.WriteLine("Listening on " + baseAddress); }
private static void Main(string[] args) { string prefix = "http://localhost:8080"; HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(prefix); config.Routes.MapHttpRoute("Default", "{controller}/{action}"); // Append our custom valueprovider to the list of value providers. config.Services.Add(typeof (ValueProviderFactory), new HeaderValueProviderFactory()); HttpSelfHostServer server = new HttpSelfHostServer(config); server.OpenAsync().Wait(); try { // HttpClient will make the call, but won't set the headers for you. HttpClient client = new HttpClient(); var response = client.GetAsync(prefix + "/ValueProviderTest/GetStuff?id=20").Result; // Browsers will set the headers. // Loop. You can hit the request via: http://localhost:8080/Test2/GetStuff?id=40 while (true) { Thread.Sleep(1000); Console.Write("."); } } finally { server.CloseAsync().Wait(); } }
private HttpSelfHostConfiguration GetHttpConfiguration() { var config = new HttpSelfHostConfiguration(BaseAddress); config.Routes.MapHttpRoute("Locator", "api.xml", new {controller = "ApiXml"}); config.Routes.MapHttpRoute("Api", "api.asp", new {controller = "ApiAsp"}); return config; }
static void Main(string[] args) { HttpSelfHostServer server = null; try { HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(baseAddress); config.HostNameComparisonMode = HostNameComparisonMode.Exact; // Register default route config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}" ); server = new HttpSelfHostServer(config); server.OpenAsync().Wait(); Console.WriteLine("Listening on " + baseAddress); Console.WriteLine("Hit ENTER to exit..."); Console.ReadLine(); } catch (Exception e) { Console.WriteLine("Could not start server: {0}", e.GetBaseException().Message); Console.WriteLine("Hit ENTER to exit..."); Console.ReadLine(); } finally { if (server != null) { server.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 }; }
private static HttpSelfHostConfiguration GetSettings() { var localhostAddress = ConfigurationManager.AppSettings[SettingsHelper.KEY_LOCALHOST_ADDRESS]; var serverConfiguration = new HttpSelfHostConfiguration(localhostAddress); serverConfiguration.Filters .Add(new ExceptionResponseFilterAttribute()); serverConfiguration.Routes .MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{parameters}", defaults: new { parameters = RouteParameter.Optional } ); var xmlFormatter = serverConfiguration.Formatters.OfType<XmlMediaTypeFormatter>().First(); var jsonFormatter = serverConfiguration.Formatters.OfType<JsonMediaTypeFormatter>().First(); var cors = new EnableCorsAttribute("*", "GET", "GET"); serverConfiguration.EnableCors(cors); serverConfiguration.Formatters.Remove(xmlFormatter); jsonFormatter.SerializerSettings = new JsonSerializerSettings() { ContractResolver = new CamelCasePropertyNamesContractResolver() }; return serverConfiguration; }
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 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; }
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) { // 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(); } }
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(); }
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(); //} }
public PrinterService() { InitializeComponent(); config = new HttpSelfHostConfiguration(AppConfig.BaseUrl); config.MapHttpAttributeRoutes(); }
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; } }
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 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(); }
private static HttpSelfHostConfiguration getHostConfiguration(string serverUri, bool allowRemoteConnections) { var config = new HttpSelfHostConfiguration(serverUri) { // to avoid `(413) Request Entity Too Large` exceptions MaxReceivedMessageSize = int.MaxValue, MaxBufferSize = int.MaxValue }; if (!allowRemoteConnections) { // Only clients from the local machine will be able to invoke the hosted REST API. // It does NOT require admin privileges or a URL reservation. config.HostNameComparisonMode = HostNameComparisonMode.Exact; } config.Routes.MapHttpRoute( "API Default", "api/{controller}/{id}", new { id = RouteParameter.Optional }); var jsonSettings = new JsonSerializerSettings(); jsonSettings.Converters.Add(new StringEnumConverter()); config.Formatters.JsonFormatter.SerializerSettings = jsonSettings; return config; }
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(); } }
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(); } }
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; }
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(); } }
private static void Configure(HttpSelfHostConfiguration config) { config.Routes.MapHttpRoute("Default Route", "api/{controller}", new { controller = "Home" }); config.Formatters.XmlFormatter.SupportedMediaTypes.Clear(); config.Filters.Add(new ServiceControlErrorFilter()); config.Filters.Add(new VersionInformationFilter()); }
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); }
/// <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 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(); } }
public void HttpSelfHostConfiguration_CorrectClientCredentialType_WithX509CertificateValidator_Works(string address, HttpBindingSecurityMode mode, HttpClientCredentialType clientCredentialType) { // Arrange GC.KeepAlive(mode); // Mark parameter as used. See xUnit1026, [Theory] method doesn't use all parameters. HttpBinding binding = new HttpBinding(); HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(address) { X509CertificateValidator = new Mock <X509CertificateValidator>().Object }; config.ClientCredentialType = clientCredentialType; // Act BindingParameterCollection parameters = config.ConfigureBinding(binding); }
public void HttpSelfHostConfiguration_CorrectClientCredentialType_WithUsernamePasswordValidator_Works(string address, HttpBindingSecurityMode mode, HttpClientCredentialType clientCredentialType) { // Arrange GC.KeepAlive(mode); // Mark parameter as used. See xUnit1026, [Theory] method doesn't use all parameters. HttpBinding binding = new HttpBinding(); HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(address) { UserNamePasswordValidator = new CustomUsernamePasswordValidator() }; config.ClientCredentialType = clientCredentialType; // Act BindingParameterCollection parameters = config.ConfigureBinding(binding); }
public void HttpSelfHostConfiguration_ClientCredentialType_PropagatesToHttpBinding(string address, HttpBindingSecurityMode mode, HttpClientCredentialType clientCredentialType) { // Arrange HttpBinding binding = new HttpBinding(); HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(address) { ClientCredentialType = clientCredentialType }; // Act BindingParameterCollection parameters = config.ConfigureBinding(binding); Assert.Equal(clientCredentialType, binding.Security.Transport.ClientCredentialType); Assert.Equal(mode, binding.Security.Mode); }
public void HttpSelfHostConfiguration_MaxBufferSize_DoesNotTrackMaxReceivedMessageSizeWhenSet( long maxReceivedMessageSize, int maxBufferSize ) { // Arrange HttpSelfHostConfiguration config = new HttpSelfHostConfiguration("http://localhost"); config.MaxBufferSize = maxBufferSize; config.MaxReceivedMessageSize = maxReceivedMessageSize; // Act & Assert Assert.Equal(maxBufferSize, config.MaxBufferSize); Assert.Equal(maxReceivedMessageSize, config.MaxReceivedMessageSize); }
public void SetupHost() { baseAddress = String.Format("http://localhost:{0}/", HttpSelfHostServerTest.TestPort); HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(baseAddress); 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 HttpSelfHostConfiguration_WrongClientCredentialType_WithUsernamePasswordValidator_Throws(string address, HttpBindingSecurityMode mode, HttpClientCredentialType clientCredentialType) { // Arrange HttpBinding binding = new HttpBinding(); HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(address) { UserNamePasswordValidator = new CustomUsernamePasswordValidator() }; config.ClientCredentialType = clientCredentialType; Assert.Throws <InvalidOperationException>(() => { // Act BindingParameterCollection parameters = config.ConfigureBinding(binding); }); }
public void HttpSelfHostConfiguration_WrongClientCredentialType_WithX509CertificateValidator_Throws(string address, HttpBindingSecurityMode mode, HttpClientCredentialType clientCredentialType) { // Arrange HttpBinding binding = new HttpBinding(); HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(address) { X509CertificateValidator = new Mock <X509CertificateValidator>().Object }; config.ClientCredentialType = clientCredentialType; Assert.Throws <InvalidOperationException>(() => { // Act BindingParameterCollection parameters = config.ConfigureBinding(binding); }); }
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 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 void HttpSelfHostConfiguration_ClientCredentialType_RoundTrips() { HttpSelfHostConfiguration config = new HttpSelfHostConfiguration("http://localhost"); Assert.Reflection.EnumPropertyWithoutIllegalValueCheck <HttpSelfHostConfiguration, HttpClientCredentialType>( config, c => c.ClientCredentialType, expectedDefaultValue: HttpClientCredentialType.None, roundTripTestValue: HttpClientCredentialType.Windows); // now let us check the illegal value differently config.ClientCredentialType = (HttpClientCredentialType)999; Assert.ThrowsArgumentOutOfRange( () => { new HttpSelfHostServer(config).OpenAsync().Wait(); }, "value", null, false, 999); }
public void HttpSelfHostConfiguration_NegativeTimeouts_ThrowArgumentOutOfRange() { HttpSelfHostConfiguration config = new HttpSelfHostConfiguration("http://localhost"); TimeSpan negativeTimeout = new TimeSpan(-1, 0, 0); Assert.ThrowsArgumentGreaterThanOrEqualTo( () => config.ReceiveTimeout = negativeTimeout, "value", "00:00:00", "-01:00:00" ); Assert.ThrowsArgumentGreaterThanOrEqualTo( () => config.SendTimeout = negativeTimeout, "value", "00:00:00", "-01:00:00" ); }
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); }
public void HttpSelfHostConfiguration_UseWindowsAuth_PropagatesToHttpBinding(string address, HttpBindingSecurityMode mode) { // Arrange HttpBinding binding = new HttpBinding(); HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(address) { UseWindowsAuthentication = true }; // Act BindingParameterCollection parameters = config.ConfigureBinding(binding); // Assert Assert.NotNull(parameters); ServiceCredentials serviceCredentials = parameters.Find <ServiceCredentials>(); Assert.NotNull(serviceCredentials); Assert.Equal(HttpClientCredentialType.Windows, binding.Security.Transport.ClientCredentialType); Assert.Equal(mode, binding.Security.Mode); }
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 void HttpSelfHostConfiguration_Settings_PropagateToBinding() { // Arrange HttpBinding binding = new HttpBinding(); HttpSelfHostConfiguration config = new HttpSelfHostConfiguration("http://localhost") { MaxBufferSize = 10, MaxReceivedMessageSize = 11, TransferMode = TransferMode.StreamedResponse, HostNameComparisonMode = HostNameComparisonMode.WeakWildcard }; // Act config.ConfigureBinding(binding); // Assert Assert.Equal(10, binding.MaxBufferSize); Assert.Equal(11, binding.MaxReceivedMessageSize); Assert.Equal(TransferMode.StreamedResponse, binding.TransferMode); Assert.Equal(HostNameComparisonMode.WeakWildcard, binding.HostNameComparisonMode); }
public void HttpSelfHostConfiguration_UserNamePasswordValidator_PropagatesToBinding(string address, HttpBindingSecurityMode mode) { // Arrange HttpBinding binding = new HttpBinding(); UserNamePasswordValidator validator = new Mock <UserNamePasswordValidator>().Object; HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(address) { UserNamePasswordValidator = validator }; // Act BindingParameterCollection parameters = config.ConfigureBinding(binding); // Assert Assert.NotNull(parameters); ServiceCredentials serviceCredentials = parameters.Find <ServiceCredentials>(); Assert.NotNull(serviceCredentials); Assert.Equal(HttpClientCredentialType.Basic, binding.Security.Transport.ClientCredentialType); Assert.Equal(mode, binding.Security.Mode); }
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(); } }