public void Host_StartupOk_RespondsOnHttpRequest()
{
const string content = "<h1>Test</h1>";
var options = new StonehengeHostOptions
{
Title = "Test"
};
var loader = new TestResourceLoader(content);
var host = new KestrelHost(loader, options);
var startOk = host.Start("localhost", 32001);
Assert.True(startOk, "Start failed");
var response = string.Empty;
try
{
using var client = new RedirectableWebClient();
response = client.DownloadString(host.BaseUrl);
}
catch (Exception ex)
{
_logger.LogError(ex, nameof(Host_StartupOk_RespondsOnHttpRequest));
}
Assert.Equal(content, response);
host.Terminate();
}
protected override void ConfigureKestrelHost(KestrelHost host)
{
host
.WithChannelType(_channelType)
.ConfigureServices(services => services.AddTransient <IServiceWithAuthentication, ServiceWithAuthentication>())
.ConfigureEndpoints(endpoints => endpoints.MapGrpcService <IServiceWithAuthentication>());
}
public async Task BeforeAll()
{
_host = await new KestrelHost()
.ConfigureServices(services =>
{
services.AddTransient <TrackingServerFilter>();
services.AddServiceModelGrpc(options =>
{
options.Filters.Add(1, _ => new TrackingServerFilter("global"));
});
services.AddServiceModelGrpcServiceOptions <TrackedFilteredService>(options =>
{
options.Filters.Add(2, _ => new TrackingServerFilter("service-options"));
});
})
.ConfigureEndpoints(endpoints =>
{
endpoints.MapGrpcService <TrackedFilteredService>();
})
.StartAsync()
.ConfigureAwait(false);
DomainService = _host.ClientFactory.CreateClient <IFilteredService>(_host.Channel);
}
public async Task BeforeAll()
{
_host = await new KestrelHost()
.ConfigureServices(services =>
{
services.AddGrpc(options =>
{
options.ResponseCompressionAlgorithm = options.CompressionProviders[0].EncodingName;
options.ResponseCompressionLevel = CompressionLevel.Optimal;
});
services.AddServiceModelGrpcSwagger();
services.AddOpenApiDocument();
services.AddMvc();
})
.ConfigureApp(app =>
{
app.UseOpenApi(); // serve OpenAPI/Swagger documents
app.UseSwaggerUi3(); // serve Swagger UI
app.UseReDoc(); // serve ReDoc UI
app.UseServiceModelGrpcSwaggerGateway();
})
.ConfigureEndpoints(endpoints =>
{
endpoints.MapGrpcService <MultipurposeService>();
})
.StartAsync(HttpProtocols.Http1)
.ConfigureAwait(false);
var document = await OpenApiDocument
.DownloadAsync(_host.GetLocation("swagger/v1/swagger.json"))
.ConfigureAwait(false);
_client = new SwaggerUiClient(document, nameof(IMultipurposeService), _host.GetLocation());
}
public async Task BeforeAll()
{
_host = await new KestrelHost()
.ConfigureServices(services =>
{
services.AddServiceModelGrpcSwagger();
services.AddOpenApiDocument();
services.AddMvc();
})
.ConfigureApp(app =>
{
app.UseOpenApi(); // serve OpenAPI/Swagger documents
app.UseSwaggerUi3(); // serve Swagger UI
app.UseReDoc(); // serve ReDoc UI
app.UseServiceModelGrpcSwaggerGateway();
})
.ConfigureEndpoints(endpoints =>
{
endpoints.MapGrpcService <HeadersService>();
})
.StartAsync(HttpProtocols.Http1)
.ConfigureAwait(false);
var document = await OpenApiDocument
.DownloadAsync(_host.GetLocation("swagger/v1/swagger.json"))
.ConfigureAwait(false);
_client = new SwaggerUiClient(document, nameof(IHeadersService), _host.GetLocation());
}
public async Task BeforeAll()
{
_host = await new KestrelHost()
.ConfigureClientFactory(options => options.ErrorHandler = new ClientErrorHandler())
.ConfigureServices(services =>
{
services.AddScoped <ServerErrorHandler>();
services.AddTransient <IErrorService, ErrorService>();
AddErrorServiceOptions(
services,
options =>
{
options.ErrorHandlerFactory = p => p.GetRequiredService <ServerErrorHandler>();
});
})
.ConfigureEndpoints(endpoints =>
{
MapErrorService(endpoints);
})
.StartAsync()
.ConfigureAwait(false);
DomainService = _host.ClientFactory.CreateClient <IErrorService>(_host.Channel);
}
private static void Main(string[] args)
{
Console.WriteLine(@"nossued website");
// client framework (use Vue.js)
var vue = new VueResourceProvider();
var provider = StonehengeResourceLoader.CreateDefaultLoader(vue);
// options
var options = new StonehengeHostOptions
{
Title = "NOSSUED",
StartPage = "home",
ServerPushMode = ServerPushModes.LongPolling,
PollIntervalMs = 5000
};
// hosting
var host = new KestrelHost(provider, options);
if (!host.Start("localhost", 32000))
{
Console.WriteLine(@"Failed to start server on: " + host.BaseUrl);
Environment.Exit(1);
}
// wait for user pressing Ctrl+C to terminate
var terminate = new AutoResetEvent(false);
Console.CancelKeyPress += (sender, eventArgs) => { terminate.Set(); };
Console.WriteLine(@"Started server on: " + host.BaseUrl);
terminate.WaitOne();
Console.WriteLine(@"Server terminated.");
host.Terminate();
}
// ReSharper disable once UnusedParameter.Local
private static void Main(string[] args)
{
Console.WriteLine("Sample showing stonehenge on Chromely");
// stonehenge backend
var options = new StonehengeHostOptions
{
Title = "Demo"
};
var provider = StonehengeResourceLoader
.CreateDefaultLoader(new VueResourceProvider());
var host = new KestrelHost(provider, options);
if (!host.Start(options.Title, false, "localhost", 8888))
{
Console.WriteLine("Failed to start stonehenge server");
}
// ensure CEF runtime files are present
var path = Path.GetDirectoryName(Assembly.GetEntryAssembly().Location) ?? ".";
Directory.SetCurrentDirectory(path);
try
{
CefRuntime.Load();
}
catch (Exception ex)
{
Console.WriteLine("Failed to load runtime: " + ex.Message);
Console.WriteLine("Installing CEF runtime from " + CefLoader.CefBuildsDownloadUrl);
CefLoader.Load();
}
// chromely frontend
var startUrl = host.BaseUrl;
var config = ChromelyConfiguration
.Create()
.WithHostMode(WindowState.Normal, true)
.WithHostTitle(options.Title)
//.WithHostIconFile("chromely.ico")
.WithAppArgs(args)
.WithHostSize(1000, 600)
.WithStartUrl(startUrl);
using (var window = new CefGlueBrowserWindow(config))
{
var exitCode = window.Run(args);
if (exitCode != 0)
{
Console.WriteLine("Failed to start chromely frontend: code " + exitCode);
}
}
Console.WriteLine("Demo done.");
}
private static void Main(string[] args)
{
Trace.Listeners.Add(new TextWriterTraceListener(Console.Out));
var path = ApplicationInfo.ApplicationDirectory;
Directory.SetCurrentDirectory(path);
var settingsFile = new Profile(Path.Combine(path, "GitState.cfg"));
new ProfileClassLoader().LoadClass(Settings, settingsFile);
// Starting stonehenge backend
var options = new StonehengeHostOptions
{
Title = "GitState",
StartPage = "main",
ServerPushMode = ServerPushModes.LongPolling,
PollIntervalSec = 10
};
var logger = Logger.DefaultFactory.CreateLogger("GitState");
var provider = StonehengeResourceLoader
.CreateDefaultLoader(logger, new VueResourceProvider(logger));
var host = new KestrelHost(provider, options);
if (!host.Start("localhost", 8880))
{
Console.WriteLine("Failed to start stonehenge server");
}
// Starting chromely frontend
Console.WriteLine("Starting chromely frontend");
var config = DefaultConfiguration.CreateForRuntimePlatform();
config.CefDownloadOptions = new CefDownloadOptions(true, true);
config.StartUrl = host.BaseUrl;
config.WindowOptions = new WindowOptions
{
Title = "GitState",
Size = new WindowSize(Settings.WindowWidth, Settings.WindowHeight),
RelativePathToIconFile = "GitState.ico"
};
config.DebuggingMode = true;
AppBuilder
.Create()
.UseApp <ChromelyBasicApp>()
.UseConfig <IChromelyConfiguration>(config)
.Build()
.Run(args);
Console.ReadLine();
Console.WriteLine("GitState done.");
}
public async Task BeforeAll()
{
_host = await new KestrelHost()
.ConfigureEndpoints(endpoints =>
{
endpoints.MapGrpcService <Calculator>();
})
.StartAsync();
_calculator = _host.ClientFactory.CreateClient <ICalculator>(_host.Channel);
}
private static void Main()
{
Console.WriteLine("NOSSUED InfoScreenServer");
var cfgFile = Path.Combine(Application.GetApplicationDirectory(), "InfoScreen.cfg");
var profile = new Profile(cfgFile);
var settings = new InfoSettings();
var spp = new ClassPropertyProvider(settings);
spp.SetProperties(profile["Event"].Properties);
spp.SetProperties(profile["Twitter"].Properties);
Console.WriteLine($"Event {settings.Name}, Keyword = {settings.Keywords}");
var key = ""; //Environment.GetEnvironmentVariable("twitter-key");
var secret = ""; //Environment.GetEnvironmentVariable("twitter-secret");
_client = new TwitterClient(settings);
if (string.IsNullOrEmpty(key) || string.IsNullOrEmpty(secret))
{
Console.WriteLine("Missing twitter auth - start demo mode");
var tweets = Path.Combine(Application.GetApplicationDirectory(), "DemoTweets.json");
var json = File.ReadAllText(tweets);
_client.Tweets = JsonConvert.DeserializeObject <List <TwitterMessage> >(json);
}
else
{
_client.Connect(key, secret);
}
var vue = new VueResourceProvider();
var provider = StonehengeResourceLoader.CreateDefaultLoader(vue);
provider.Services.AddService(typeof(TwitterClient), _client);
provider.Services.AddService(typeof(InfoSettings), settings);
var options = new StonehengeHostOptions
{
Title = settings.Name
};
var host = new KestrelHost(provider, options);
host.Start("localhost", 32000);
Process.Start(new ProcessStartInfo(host.BaseUrl)
{
UseShellExecute = true
});
Console.ReadLine();
_client.Dispose();
}
public async Task BeforeAll()
{
_host = await new KestrelHost()
.ConfigureClientFactory(options => options.DefaultCallOptionsFactory = () => new CallOptions(DefaultMetadata))
.ConfigureEndpoints(endpoints =>
{
endpoints.MapGrpcService <HeadersService>();
})
.StartAsync();
DomainService = _host.ClientFactory.CreateClient <IHeadersService>(_host.Channel);
}
public async Task BeforeAll()
{
_grpcHost = await new KestrelHost()
.ConfigureClientFactory(options => options.MarshallerFactory = ProtobufMarshallerFactory.Default)
.ConfigureEndpoints(endpoints => endpoints.MapGrpcService <GreeterService>())
.StartAsync();
_serviceModelHost = await new KestrelHost(8081)
.ConfigureClientFactory(options => options.MarshallerFactory = ProtobufMarshallerFactory.Default)
.ConfigureEndpoints(endpoints => endpoints.MapGrpcService <DomainGreeterService>())
.StartAsync();
}
static void Main(string[] args)
{
Console.WriteLine("SunSpec Explorer");
var consoleListener = new ConsoleTraceListener();
Trace.Listeners.Add(consoleListener);
var options = new StonehengeHostOptions
{
Title = "SunSpec Explorer",
StartPage = "explorer",
ServerPushMode = ServerPushModes.LongPolling,
PollIntervalMs = 5000
};
var vue = new VueResourceProvider();
var provider = StonehengeResourceLoader.CreateDefaultLoader(vue);
//provider.Services.AddService(typeof(InformantEngine), _engine);
var host = new KestrelHost(provider, options);
if (!host.Start("localhost", 8080))
{
Console.WriteLine("Failed to start stonehenge server");
}
var config = DefaultConfiguration.CreateForRuntimePlatform();
config.CefDownloadOptions = new CefDownloadOptions
{
AutoDownloadWhenMissing = true,
DownloadSilently = true
};
config.WindowOptions = new WindowOptions
{
Title = " ",
//RelativePathToIconFile = "Informant.ico",
Size = new WindowSize(
(int)(1000 * Display.GetScalingFactor()),
(int)(600 * Display.GetScalingFactor()))
};
config.DebuggingMode = true;
config.StartUrl = host.BaseUrl;
AppBuilder
.Create()
.UseConfiguration <IChromelyConfiguration>(config)
.UseApp <ChromelyBasicApp>()
.Build()
.Run(args);
}
public async Task BeforeAll()
{
_host = await new KestrelHost()
.ConfigureEndpoints(endpoints =>
{
endpoints.MapGrpcService <GreeterService>();
endpoints.MapGrpcService <MultipurposeService>();
})
.StartAsync();
DomainService = _host.ClientFactory.CreateClient <IMultipurposeService>(_host.Channel);
_greeterService = new Greeter.GreeterClient(_host.Channel);
}
public void Host_MultipleInstances_StartupOk_RespondsOnHttpRequest()
{
const string content1 = "<h1>Test 01</h1>";
const string content2 = "<h1>Test II</h1>";
var options = new StonehengeHostOptions
{
Title = "Test"
};
var loader1 = new TestResourceLoader(content1);
var host1 = new KestrelHost(loader1, options);
var startOk = host1.Start("localhost", 32002);
Assert.True(startOk, "Start host1 failed");
var loader2 = new TestResourceLoader(content2);
var host2 = new KestrelHost(loader2, options);
startOk = host2.Start("localhost", 32003);
Assert.True(startOk, "Start host2 failed");
Assert.NotEqual(host1.BaseUrl, host2.BaseUrl);
var response1 = string.Empty;
var response2 = string.Empty;
try
{
using (var client = new RedirectableWebClient())
{
response1 = client.DownloadString(host1.BaseUrl);
}
using (var client = new RedirectableWebClient())
{
response2 = client.DownloadString(host2.BaseUrl);
}
}
catch (Exception ex)
{
_logger.LogError(ex, nameof(Host_MultipleInstances_StartupOk_RespondsOnHttpRequest));
Assert.True(false, ex.Message);
}
Assert.Equal(content1, response1);
Assert.Equal(content2, response2);
host1.Terminate();
host2.Terminate();
}
public async Task BeforeAll()
{
_host = await new KestrelHost()
.ConfigureEndpoints(endpoints =>
{
endpoints.MapGrpcService <ConcreteContract1>();
endpoints.MapGrpcService <ConcreteContract2>();
})
.StartAsync()
.ConfigureAwait(false);
DomainService1 = _host.ClientFactory.CreateClient <IConcreteContract1>(_host.Channel);
DomainService2 = _host.ClientFactory.CreateClient <IConcreteContract2>(_host.Channel);
}
// ReSharper disable once UnusedParameter.Local
private static void Main(string[] args)
{
Console.WriteLine("IctBaden.Modbus.SampleDevice");
Trace.Listeners.Add(new TronTraceListener(true));
var logger = Framework.Logging.Logger.DefaultFactory.CreateLogger("Modbus");
var source = new TestData();
var device = new ModbusSlave("Sample", source, 1502, 1);
device.Start();
var options = new StonehengeHostOptions
{
Title = "Modbus",
StartPage = "device",
ServerPushMode = ServerPushModes.LongPolling,
PollIntervalSec = 5
};
var vue = new VueResourceProvider(logger);
var provider = StonehengeResourceLoader.CreateDefaultLoader(logger, vue);
provider.Services.AddService(typeof(TestData), source);
provider.Services.AddService(typeof(ModbusSlave), device);
var host = new KestrelHost(provider, options);
if (!host.Start("*", 0))
{
Console.WriteLine("Failed to start stonehenge server");
return;
}
var wnd = new HostWindow(host.BaseUrl, "Modbus", new Point(600, 800));
if (!wnd.Open())
{
Console.WriteLine("Failed to open window");
}
Console.WriteLine("Done.");
}
public async Task BeforeAll()
{
_host = await new KestrelHost()
.ConfigureServices(services =>
{
services.AddGrpc(options =>
{
options.ResponseCompressionAlgorithm = options.CompressionProviders[0].EncodingName;
options.ResponseCompressionLevel = CompressionLevel.Optimal;
});
services.AddServiceModelGrpcSwagger();
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo {
Title = "My API", Version = "v1"
});
c.EnableAnnotations(true, true);
});
services.AddMvc();
})
.ConfigureApp(app =>
{
app.UseSwagger();
app.UseSwaggerUI(c =>
{
c.SwaggerEndpoint("v1/swagger.json", "My API V1");
});
app.UseServiceModelGrpcSwaggerGateway();
})
.ConfigureEndpoints(endpoints =>
{
endpoints.MapGrpcService <MultipurposeService>();
})
.StartAsync(HttpProtocols.Http1)
.ConfigureAwait(false);
var document = await OpenApiDocument
.DownloadAsync(_host.GetLocation("swagger/v1/swagger.json"))
.ConfigureAwait(false);
_client = new SwaggerUiClient(document, nameof(IMultipurposeService), _host.GetLocation());
}
public void BeforeEachTest()
{
_clientMetadata = new List <Metadata.Entry>();
var clientErrorHandler = new Mock <IClientErrorHandler>(MockBehavior.Strict);
clientErrorHandler
.Setup(h => h.ThrowOrIgnore(It.IsAny <ClientCallInterceptorContext>(), It.IsAny <ClientFaultDetail>()))
.Callback <ClientCallInterceptorContext, ClientFaultDetail>((_, detail) =>
{
_clientMetadata.AddRange(detail
.OriginalError
.Trailers
.Where(i => "GlobalErrorHandler".Equals(i.Key, StringComparison.OrdinalIgnoreCase) || "LocalErrorHandler".Equals(i.Key, StringComparison.OrdinalIgnoreCase)));
});
_host = new KestrelHost()
.ConfigureClientFactory(options => options.ErrorHandler = clientErrorHandler.Object);
var globalErrorHandler = new Mock <IServerErrorHandler>(MockBehavior.Strict);
globalErrorHandler
.Setup(h => h.ProvideFaultOrIgnore(It.IsAny <ServerCallInterceptorContext>(), It.IsNotNull <Exception>()))
.Returns <ServerCallInterceptorContext, Exception>((context, ex) =>
{
ex.ShouldBeOfType <ApplicationException>();
context.ServerCallContext.ResponseTrailers.Add(new Metadata.Entry("GlobalErrorHandler", "dummy"));
return(null);
});
_globalErrorHandler = globalErrorHandler.Object;
var localErrorHandler = new Mock <IServerErrorHandler>(MockBehavior.Strict);
localErrorHandler
.Setup(h => h.ProvideFaultOrIgnore(It.IsAny <ServerCallInterceptorContext>(), It.IsNotNull <Exception>()))
.Returns <ServerCallInterceptorContext, Exception>((context, ex) =>
{
ex.ShouldBeOfType <ApplicationException>();
context.ServerCallContext.ResponseTrailers.Add(new Metadata.Entry("LocalErrorHandler", "dummy"));
return(null);
});
_localErrorHandler = localErrorHandler.Object;
}
public async Task BeforeAll()
{
_host = new KestrelHost()
.ConfigureServices(services =>
{
AddMultipurposeServiceOptions(
services,
o =>
{
});
})
.ConfigureEndpoints(endpoints =>
{
MapMultipurposeService(endpoints);
});
await _host.StartAsync().ConfigureAwait(false);
_host.ClientFactory.AddMultipurposeServiceClient();
DomainService = _host.ClientFactory.CreateClient <IMultipurposeService>(_host.Channel);
}
public async Task BeforeAll()
{
_host = await new KestrelHost()
.ConfigureClientFactory(options => options.ErrorHandler = new ClientErrorHandler())
.ConfigureServices(services =>
{
services.AddScoped <ServerErrorHandler>();
services.AddServiceModelGrpc(options =>
{
options.DefaultErrorHandlerFactory = p => p.GetRequiredService <ServerErrorHandler>();
});
})
.ConfigureEndpoints(endpoints =>
{
endpoints.MapGrpcService <ErrorService>();
})
.StartAsync();
DomainService = _host.ClientFactory.CreateClient <IErrorService>(_host.Channel);
}
public async Task BeforeAll()
{
_host = await new KestrelHost()
.ConfigureServices(services =>
{
services.AddServiceModelGrpcSwagger();
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new OpenApiInfo {
Title = "My API", Version = "v1"
});
c.EnableAnnotations(true, true);
});
services.AddMvc();
})
.ConfigureApp(app =>
{
app.UseSwagger();
app.UseSwaggerUI(c =>
{
c.SwaggerEndpoint("v1/swagger.json", "My API V1");
});
app.UseServiceModelGrpcSwaggerGateway();
})
.ConfigureEndpoints(endpoints =>
{
endpoints.MapGrpcService <HeadersService>();
})
.StartAsync(HttpProtocols.Http1)
.ConfigureAwait(false);
var document = await OpenApiDocument
.DownloadAsync(_host.GetLocation("swagger/v1/swagger.json"))
.ConfigureAwait(false);
_client = new SwaggerUiClient(document, nameof(IHeadersService), _host.GetLocation());
}
static void Main(string[] args)
{
KestrelHost.Create <Startup>()
.BuildHost()
.Run();
}
protected override void ConfigureKestrelHost(KestrelHost host)
{
host
.ConfigureServices(services => services.AddTransient <IServiceWithAuthentication, ServiceWithAuthentication>())
.ConfigureEndpoints(endpoints => MapServiceWithAuthentication(endpoints));
}
protected override void ConfigureKestrelHost(KestrelHost host)
{
host.ConfigureEndpoints(endpoints => MapServiceWithAuthentication(endpoints));
}
public void GlobalSetup()
{
_kestrelHost = new KestrelHost();
}