public static void Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.WriteTo
.ColoredConsole()
.MinimumLevel.Verbose()
.CreateLogger();
var streamStore = new InMemoryStreamStore();
var builder = new AppBuilder();
builder.Use(SqlStreamStoreHalMiddleware.UseSqlStreamStoreHal(streamStore));
var server = ServerBuilder.New()
.SetEndPoint(new IPEndPoint(IPAddress.Loopback, 8080))
.SetOwinApp(builder.Build());
using (streamStore)
using (server.Build())
using (server.Start())
{
DisplayMenu(streamStore);
}
}
private void Awake()
{
m_match = new Match();
switch (m_matchControlType)
{
case MatchControlType.Local:
{
var userInput = new MouseAndKbInput();
m_matchCtrl = new LocalMatchController(m_match, userInput);
m_matchView.Init(m_match);
break;
}
case MatchControlType.Client:
{
m_match.SetLogic(new ClientMatchLogic(m_match));
m_matchCtrl = ClientBuilder.Create(m_match, m_matchView);
break;
}
case MatchControlType.Server:
{
m_match.SetLogic(new ServerMatchLogic(m_match));
m_matchCtrl = ServerBuilder.Create(m_match);
m_matchView.Init(m_match);
break;
}
}
}
static void Main(string[] args)
{
var owinbuilder = new AppBuilder();
OwinServerFactory.Initialize(owinbuilder.Properties);
new SampleOwinApp.Startup().Configuration(owinbuilder);
var builder = ServerBuilder.New()
.SetPort(8888)
.SetOwinApp(owinbuilder.Build())
.SetOwinCapabilities((IDictionary <string, object>)owinbuilder.Properties[OwinKeys.ServerCapabilitiesKey])
.SetExecutionContextFlow(ExecutionContextFlow.SuppressAlways);
//builder
// .SetCertificate(new X509Certificate2("../../../sslcert/test.pfx", "nowin"))
// .RequireClientCertificate();
using (var server = builder.Build())
{
// Workaround for bug in Windows Server 2012 when ReadLine is called directly after AcceptAsync
// By starting it in another thread and probably even later than calling readline it works
Task.Run(() => server.Start());
//using (new Timer(o =>
// {
// var s = (INowinServer)o;
// Console.WriteLine("Connections {0}/{1}", s.ConnectionCount, s.CurrentMaxConnectionCount);
// }, server, 2000, 2000))
{
Console.WriteLine("Listening on ports 8888. Enter to exit.");
Console.ReadLine();
}
}
}
public CrudTests()
{
_host = ServerBuilder.CreateServer();
_scope = _host.Services.CreateScope();
_serviceProvider = _scope.ServiceProvider;
_database = _serviceProvider.GetRequiredService <LactalisDBContext>();
}
private static async Task Main(string[] args)
{
try
{
ServerSettings serverSettings = new ServerSettings(new X42MainServerNode(), ProtocolVersion.PROTOCOL_VERSION, args: args);
IxServer server = new ServerBuilder()
.UseServerSettings(serverSettings)
.UseX42Client()
.UseSql()
.UseApi()
.UsePriceLock()
.UseNetwork()
.UseProfile()
.Build();
if (server != null)
{
await server.RunAsync();
}
}
catch (Exception ex)
{
Console.WriteLine($@"There was a problem initializing xServer. Details: '{ex}'");
}
}
static async Task Main(string[] args)
{
var services = new ServiceCollection();
services.AddLogging(builder =>
{
builder.SetMinimumLevel(LogLevel.Trace);
builder.AddConsole();
});
var serviceProvider = services.BuildServiceProvider();
var server = new ServerBuilder(serviceProvider)
.UseSockets(sockets =>
{
sockets.Listen(IPAddress.Loopback, 0, builder => { });
})
.Build();
await server.StartAsync();
foreach (var ep in server.EndPoints)
{
Console.WriteLine($"Listening on {ep}");
}
var tcs = new TaskCompletionSource <object>();
Console.CancelKeyPress += (sender, e) => tcs.TrySetResult(null);
await tcs.Task;
await server.StopAsync();
}
public Task StartAsync(CancellationToken cancellationToken)
{
//构建Server
var serverBuilder = new ServerBuilder();
var serverOptions = _conf.GetSection("services:GreeterServer").Get <LocalServiceOption>();
_server = serverBuilder.UseGrpcOptions(serverOptions)
.UseInterceptor(_serverInterceptors) //使用中间件
.UseGrpcService(Greeter.BindService(new GreeterImpl()))
.UseLogger(log => //使用日志
{
log.LoggerMonitor = info => Console.WriteLine(info);
log.LoggerError = exception => Console.WriteLine(exception);
})
.Build();
var innerLogger = new Grpc.Core.Logging.LogLevelFilterLogger(new Grpc.Core.Logging.ConsoleLogger(), Grpc.Core.Logging.LogLevel.Debug);
GrpcEnvironment.SetLogger(innerLogger);
_server.UseDashBoard() //使用DashBoard,需要使用FM.GrpcDashboard网站
.StartAndRegisterService(); //启动服务并注册到consul
return(Task.CompletedTask);
}
public static void AddPhysics(this ServerBuilder builder)
{
builder.ConfigureServices(services =>
{
services.AddSingleton <PhysicsService>();
});
}
public static void Main(string[] args)
{
var container = GetIoC();
var owinAppBuilder = (IAppBuilder) new AppBuilder();
var provider = container.Get <ISomeServiceProvider>();
var config = container.Get <HttpConfiguration>();
ConfigureOAuth(owinAppBuilder, provider);
owinAppBuilder.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
owinAppBuilder.UseWebApi(config);
//Build Owin App
var owinApp = (AppFunc)owinAppBuilder.Build(typeof(AppFunc));
//Make an endpoint
var owinEndpoint = new System.Net.IPEndPoint(System.Net.IPAddress.Any, 8080);
//Build WebServer (Nowin)
var owinServer = ServerBuilder.New()
.SetOwinApp(owinApp)
.SetEndPoint(owinEndpoint)
.Build();
// Start WebServer
using (owinServer)
{
owinServer.Start();
Console.WriteLine("Press ENTER to stop");
Console.ReadLine();
}
}
public static ServerBuilder AddCaseJobServer(this IServiceCollection services, Action <CMMNServerOptions> callback = null, Action <CommonOptions> callbackOpts = null)
{
if (callback == null)
{
services.Configure <CMMNServerOptions>((o) => { });
}
else
{
services.Configure(callback);
}
if (callbackOpts == null)
{
services.Configure <CommonOptions>((o) =>
{
o.ApplicationAssembly = typeof(ICaseJobServer).Assembly;
});
}
else
{
services.Configure(callbackOpts);
}
var builder = new ServerBuilder(services);
services.AddCommon()
.AddCaseJobServerApplication();
return(builder);
}
static void Main(string[] args)
{
var server = new ServerBuilder().
UseTcp(1000).
RegisterPacketHandler <PingPacket, PingPacketHandler>().
UseMessagePack().
ConfigureLogging(loggingBuilder =>
{
loggingBuilder.AddConsole();
loggingBuilder.SetMinimumLevel(LogLevel.Debug);
}).
Build();
server.Start();
var client = new ClientBuilder().
UseIp("127.0.0.1").
UseTcp(1000).
UseMessagePack().
Build();
client.Connect();
for (int i = 0; i < 10; i++)
{
client.Send(new PingPacket(DateTime.Now));
Thread.Sleep(1000);
}
Console.WriteLine("Done. Press any key to continue...");
Console.ReadLine();
}
public static void AddLuaMapping <T>(this ServerBuilder builder, Func <T, LuaValue> mapper) where T : class
{
builder.AddBuildStep((x) =>
{
x.GetRequiredService <LuaValueMapper>().DefineMapper <T>(mapper);
}, ServerBuildStepPriority.Low);
}
public static void AddLuaMapping(this ServerBuilder builder, Type type, Func <object, LuaValue> mapper)
{
builder.AddBuildStep((x) =>
{
x.GetRequiredService <LuaValueMapper>().DefineMapper(type, mapper);
}, ServerBuildStepPriority.Low);
}
public AsyncTcpServer(ushort port)
{
serviceCollection = new ServiceCollection();
serviceCollection.AddLogging(builder =>
{
builder.SetMinimumLevel(LogLevel.Debug);
builder.AddConsole();
});
serviceCollection.AddSignalR();
serviceProvider = serviceCollection.BuildServiceProvider();
server = new ServerBuilder(serviceProvider)
.UseSockets(sockets =>
{
sockets.ListenAnyIP(port,
builder => {
builder.UseConnectionLogging().UseConnectionHandler <T>();
});
})
.Build();
logger = serviceProvider.GetRequiredService <ILoggerFactory>().CreateLogger <T>();
}
static void StartWebServer()
{
var appBuilder = new AppBuilder();
OwinServerFactory.Initialize(appBuilder.Properties);
appBuilder.Properties.Add("host.AppName", "QED");
fn.ConfigureBuilder(appBuilder);
var serverBuilder = ServerBuilder
.New()
.SetPort(fn.GetConfiguration <int>(Constants.Configuration.PortKey))
.SetOwinApp(appBuilder.Build())
.SetOwinCapabilities((IDictionary <string, object>)appBuilder.Properties[OwinKeys.ServerCapabilitiesKey]);
var server = serverBuilder.Start();
Console.CancelKeyPress += (sender, eventArgs) => server.Dispose();
Console.WriteLine("Started qed.");
Console.WriteLine("Listening on port {0}.", fn.GetConfiguration <int>(Constants.Configuration.PortKey));
Console.WriteLine("Press CTRL+C to exit.");
Console.WriteLine();
}
public void Init(ServerBuilder builder, ServerType type)
{
_builder = builder;
_button = GetComponent <Button>();
_button.onClick.AddListener(OnClick);
_type = type;
}
public static void AddLua(this ServerBuilder builder)
{
builder.ConfigureServices(services =>
{
services.AddLua();
});
}
public static void AddLua <T>(this ServerBuilder builder) where T : class, IScriptEventRuntime
{
builder.ConfigureServices(services =>
{
services.AddLua <T>();
});
}
private static async Task InMemoryEchoTransport(IServiceProvider serviceProvider)
{
var memoryTransport = new MemoryTransport();
var client = new ClientBuilder(serviceProvider)
.UseConnectionFactory(memoryTransport)
.UseConnectionLogging("Client")
.Build();
var server = new ServerBuilder(serviceProvider)
.Listen(endPoint: null, memoryTransport, builder =>
{
builder.UseConnectionLogging("Server").Run(connection => connection.Transport.Input.CopyToAsync(connection.Transport.Output));
})
.Build();
await server.StartAsync();
Console.WriteLine("Started Server");
var connection = await client.ConnectAsync(endpoint : null);
Console.WriteLine($"Connected to {connection.LocalEndPoint}");
Console.WriteLine("Echo server running, type into the console");
var reads = Console.OpenStandardInput().CopyToAsync(connection.Transport.Output);
var writes = connection.Transport.Input.CopyToAsync(Stream.Null);
await reads;
await writes;
await server.StopAsync();
}
public static void Main(string[] args)
{
// create a new AppBuilder
IAppBuilder app = new AppBuilder();
// init nowin's owin server factory.
OwinServerFactory.Initialize(app.Properties);
Configure(app);
var serverBuilder = new ServerBuilder();
const string ip = "127.0.0.1";
const int port = 8888;
serverBuilder.SetAddress(IPAddress.Parse(ip)).SetPort(port)
.SetOwinApp(app.Build())
.SetOwinCapabilities((IDictionary <string, object>)app.Properties[OwinKeys.ServerCapabilitiesKey]);
using (var server = serverBuilder.Build()) {
var serverRef = new WeakReference <INowinServer>(server);
Task.Run(() => {
INowinServer nowinServer;
if (serverRef.TryGetTarget(out nowinServer))
{
nowinServer.Start();
}
});
var baseAddress = "http://" + ip + ":" + port + "/";
Console.WriteLine("Nowin server listening {0}, press ENTER to exit.", baseAddress);
Console.ReadLine();
}
}
public void GetHashCode_WhenTwoDifferentInstancesAreCreated_ThenInstanceHashCodesAreNotEqual()
{
// arrange
ServerBuilder builder = ServerBuilder.Create()
.WithConnectionsAllowed(true)
.WithHostname("server.domain.local")
.WithIP("127.0.0.1")
.WithLocation("location")
.WithMaximumConnections(250)
.WithName("name");
ServerBuilder builder1 = ServerBuilder.Create()
.WithConnectionsAllowed(true)
.WithHostname("server.domain.local1")
.WithIP("127.0.0.11")
.WithLocation("location1")
.WithMaximumConnections(250)
.WithName("name1");
Server instance0 = builder.Build();
Server instance1 = builder1.Build();
// act
int result0 = instance0.GetHashCode();
int result1 = instance1.GetHashCode();
// assert
Assert.That(instance0, Is.Not.Null);
Assert.That(instance1, Is.Not.Null);
Assert.That(ReferenceEquals(instance0, instance1), Is.Not.True);
Assert.That(Equals(result0, result1), Is.False);
}
static void StartServer()
{
ServerOptions serverOptions = ServerOptions.CreateDefault();
serverOptions.Hosts[0].Port = 48050;
ServerBuilder builder = new ServerBuilder();
builder.LoadFromFile("options.json");
builder.AddAuthenticator(new ClientAuthenticator());
builder.AddAuthorization(new Authorization());
builder.AddDefaultDeliveryHandler(new DeliveryHandler());
builder.AddDefaultChannelHandler(new ChannelHandler());
builder.AddDefaultChannelAuthenticator(new ChannelAuthenticator());
TwinoServer twinoServer = new TwinoServer(serverOptions);
MqServer server = builder.CreateServer();
twinoServer.UseMqServer(server);
twinoServer.Start();
Console.WriteLine("Server started");
_server = server;
}
public MtaServer(
Action <ServerBuilder> builderAction,
Func <uint, INetWrapper, Client>?clientCreationMethod = null
)
{
this.netWrappers = new();
this.clients = new();
this.clientCreationMethod = clientCreationMethod;
this.root = new();
this.serviceCollection = new();
var builder = new ServerBuilder();
builderAction(builder);
this.configuration = builder.Configuration;
this.Password = this.configuration.Password;
this.SetupDependencies(services => builder.LoadDependencies(services));
this.serviceProvider = this.serviceCollection.BuildServiceProvider();
this.packetReducer = new(this.serviceProvider.GetRequiredService <ILogger>());
this.resourceServer = this.serviceProvider.GetRequiredService <IResourceServer>();
this.resourceServer.Start();
this.elementRepository = this.serviceProvider.GetRequiredService <IElementRepository>();
this.elementIdGenerator = this.serviceProvider.GetService <IElementIdGenerator>();
this.root.AssociateWith(this);
builder.ApplyTo(this);
}
public async Task Using_nowin_then_should_have_2_cookies()
{
using (var server = ServerBuilder
.New()
.SetEndPoint(new IPEndPoint(IPAddress.Any, _uri.Port))
.SetOwinApp(_appFunc)
.Build())
{
server.Start();
var handler = new HttpClientHandler
{
UseCookies = true
};
using (var client = new HttpClient(handler)
{
BaseAddress = _uri
})
{
var response = await client.GetAsync(_uri);
response.Headers.GetValues("Set-Cookie")
.Should()
.HaveCount(2);
}
}
}
public void Should_Not_Accept_Invalid_IP_Addres(string invalidIps)
{
Assert.Throws <ArgumentException>(() =>
ServerBuilder.New().ServerWithIp(invalidIps).Build()
)
.AssertThrowsWithMessage("IP address not valid!");
}
public static ServerBuilder BuildServer(string[] args, TaskMonitor monitor)
{
var builder = new ServerBuilder();
builder.ConfigureAppConfiguration(config =>
{
config.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", false, true)
.AddEnvironmentVariables()
.AddCommandLine(args);
})
.ConfigureLogging((config, l) =>
{
var debugLevel = config.GetValue <Extensions.Logging.LogLevel>("Logging:Debug:LogLevel:Default", Extensions.Logging.LogLevel.Debug);
l.AddConsole(config.GetSection("Logging").GetSection("Console"))
.AddDebug(debugLevel);
})
.ConfigureCloudOptions(c => c.GetSection("CloudOption").Get <CloudOption>())
.AddTaskItemSource(async(u, c, l, token) => new TaskItemSource(
await u.GetOrCreateNodeDispatchQueueAsync(c.GetValue <string>(Constants.HpcHostNameEnv), token),
TimeSpan.FromSeconds(u.Option.VisibleTimeoutSeconds),
l))
.AddWorker(async(config, u, l, token) => new NodeAgentWorker(
config,
l,
await u.GetOrCreateJobsTableAsync(token),
await u.GetOrCreateNodesTableAsync(token),
u))
.ConfigureWorker(w => ((NodeAgentWorker)w).Monitor = monitor);
return(builder);
}
public void Should_Not_Accept_Invalid_Ports(int invalidPorts)
{
Assert.Throws <ArgumentException>(() =>
ServerBuilder.New().ServerWithPort(invalidPorts).Build()
)
.AssertThrowsWithMessage("Port not valid!");
}
public void Should_Not_Accept_Name_With_Less_Than_Two_Chars(string invalidNames)
{
Assert.Throws <ArgumentException>(() =>
ServerBuilder.New().ServerWithName(invalidNames).Build()
)
.AssertThrowsWithMessage("Name length must contain more than two characters!");
}
public void Should_Not_Accept_Invalid_Name(string invalidNames)
{
Assert.Throws <ArgumentException>(() =>
ServerBuilder.New().ServerWithName(invalidNames).Build()
)
.AssertThrowsWithMessage("Name is required!");
}
private static async Task CreateAndValidateUser <T>()
where T : User, new()
{
using var host = ServerBuilder.CreateServer();
var controller = host.Services.GetRequiredService <AuthorizationController>();
var userManager = host.Services.GetRequiredService <UserManager <User> >();
// Create a user with the user manager
var entity = new EntityFactory <T>()
.UseAttributes()
.UseReferences()
.UseOwner(Guid.NewGuid())
.Generate()
.First();
var id = Guid.NewGuid().ToString();
entity.UserName = id;
entity.Email = $"{id}@example.com";
entity.NormalizedUserName = entity.UserName.ToUpper();
entity.NormalizedEmail = entity.Email.ToUpper();
entity.EmailConfirmed = false;
await userManager.CreateAsync(entity, "password");
var result = await controller.Login(new LoginDetails
{
Username = entity.UserName,
Password = "******"
});
Assert.Equal(typeof(UnauthorizedObjectResult), result.GetType());
}
public AsyncFluentCommandRegistration(ServerBuilder serverBuilder, AsyncCommandRepository repository, string command) {
_serverBuilder = serverBuilder;
_repository = repository;
_command = command;
}
public NowinServerInformation(ServerBuilder builder)
{
Builder = builder;
}
