private static CommandResult BanCommandHandler(DefaultServer server, Client sender, string command,
IList <string> args)
{
if (args.Count < 1)
{
return(CommandResult.InvalidArgument);
}
var characterName = args[0];
var client = GameServer.Instance.Server.GetClient(characterName);
if (client?.User == null)
{
return(CommandResult.Fail);
}
client.User.Status = UserStatus.Banned;
AccountModel.Update(GameServer.Instance.Database.Connection, client.User);
client.KillConnection($"Banned by {sender.User.Username}");
sender.SendChatMessage($"User {characterName} ({client.User.Username}) banned!");
return(CommandResult.Okay);
}
/// <summary>
/// Loads all necessary components and starts the server.
/// </summary>
public void Run()
{
if (_running)
{
throw new Exception("Server is already running.");
}
int x, y, width, height;
GetWindowPosition(out x, out y, out width, out height);
SetWindowPosition(0, height + 5, width, height);
ConsoleUtil.WriteHeader("Lobby Server", ConsoleColor.DarkGreen);
ConsoleUtil.LoadingTitle();
NavigateToRoot();
// Conf
LoadConf(Config = new LobbyConf());
// Database
InitDatabase(Database = new LobbyDatabase(), Config);
// Start
Server = new DefaultServer(Config.Lobby.Port);
Server.Start();
ConsoleUtil.RunningTitle();
_running = true;
// Commands
var commands = new LobbyConsoleCommands();
commands.Wait();
}
private static void Main(string[] args)
{
config = new AppConfig(args);
if (string.IsNullOrEmpty(config.MailsFolder))
{
throw new ConfigurationErrorsException("mailsFolder is null or empty");
}
if (!Directory.Exists(config.MailsFolder))
{
Directory.CreateDirectory(config.MailsFolder);
}
if (config.ClearMailsOnStartup)
{
Console.WriteLine("Clearing mail drop folder " + config.MailsFolder);
ClearFolder(config.MailsFolder);
}
List <IMessage> messages = new List <IMessage>();
//DefaultServer server = new DefaultServer(Ports.AssignAutomatically);
DefaultServer server = new DefaultServer(config.Port);
server.SessionCompleted += SessionCompleted;
server.MessageReceived += MessageReceived;
server.SessionStarted += SessionStarted;
server.Start();
//do something to send mail
Console.WriteLine("Listening on localhost at port " + server.PortNumber);
Console.WriteLine("Will write mails to folder " + config.MailsFolder);
Console.WriteLine("Press any key to quit...");
Console.ReadKey();
server.Stop();
}
public void StartOnAutomaticPort_PortNumberReturned()
{
SmtpServer server = new DefaultServer(false, StandardSmtpPort.AssignAutomatically);
server.Start();
Assert.NotEqual(0, server.PortNumber);
}
public PublisherWithAuthorizer()
{
var defaultServer = new DefaultServer
{
TransportConfiguration = new ConfigureEndpointAcceptanceTestingTransport(false, false),
};
EndpointSetup(defaultServer, (endpointConfiguration, descriptor) =>
{
endpointConfiguration.UsePersistence <FakePersistence>();
endpointConfiguration.EnableFeature <StorageAccessorFeature>();
endpointConfiguration.OnEndpointSubscribed <Context>((args, ctx) =>
{
if (args.MessageType.Contains(typeof(AllowedEvent).FullName))
{
ctx.ReceivedAllowedEventSubscriptionMessage = true;
}
if (args.MessageType.Contains(typeof(ForbiddenEvent).FullName))
{
ctx.ReceivedForbiddenEventSubscriptionMessage = true;
}
});
var routingSettings =
new RoutingSettings <AcceptanceTestingTransport>(endpointConfiguration.GetSettings());
routingSettings.SubscriptionAuthorizer(ctx =>
{
// only allow subscriptions for AllowedEvent:
return(ctx.MessageHeaders[Headers.SubscriptionMessageType]
.Contains(typeof(AllowedEvent).FullName));
});
});
}
public MessageDrivenPubSubSendOnlyEndpoint()
{
var template = new DefaultServer();
template.TransportConfiguration = new ConfigureEndpointAcceptanceTestingTransport(false, true);
EndpointSetup(template, (configuration, _) => configuration.SendOnly());
}
public NativePubSubSendOnlyEndpoint()
{
var template = new DefaultServer
{
TransportConfiguration = new ConfigureEndpointAcceptanceTestingTransport(true, true)
};
EndpointSetup(template, (configuration, _) => configuration.SendOnly());
}
public ThrottledEndpoint()
{
var template = new DefaultServer
{
PersistenceConfiguration = new ConfigureEndpointAcceptanceTestingPersistence()
};
EndpointSetup(template, (endpointConfiguration, _) => endpointConfiguration.UseTransport(new FakeTransport()));
}
public ThrottledEndpoint()
{
var template = new DefaultServer
{
PersistenceConfiguration = new ConfigureEndpointInMemoryPersistence()
};
EndpointSetup(template, (endpointConfiguration, _) => endpointConfiguration.UseTransport <FakeTransport>());
}
public void StartOnInusePort_StartupExceptionThrown()
{
Server server1 = new DefaultServer(Ports.AssignAutomatically);
server1.Start();
Server server2 = new DefaultServer(server1.PortNumber);
server2.Start();
server1.Stop();
}
public MessageDrivenPubSubSendOnlyEndpoint()
{
var template = new DefaultServer
{
TransportConfiguration = new ConfigureEndpointAcceptanceTestingTransport(false, true),
PersistenceConfiguration = new ConfigureEndpointInMemoryPersistence()
};
EndpointSetup(template, (configuration, _) => configuration.SendOnly());
}
public EndpointWithDisabledPublishing()
{
var template = new DefaultServer();
template.TransportConfiguration = new ConfigureEndpointAcceptanceTestingTransport(false, true);
EndpointSetup(template,
// DisablePublishing API is only available on the message-driven pub/sub transport settings.
(c, _) => c.GetSettings().Set("NServiceBus.PublishSubscribe.EnablePublishing", false),
pm => pm.RegisterPublisherFor <TestEvent>(typeof(MessageDrivenPublisher)));
}
public Smtp4devServer(Func <Smtp4devDbContext> dbContextFactory, IOptions <ServerOptions> serverOptions,
MessagesHub messagesHub, SessionsHub sessionsHub)
{
this.dbContextFactory = dbContextFactory;
smtpServer = new DefaultServer(serverOptions.Value.AllowRemoteConnections, serverOptions.Value.Port);
smtpServer.MessageReceived += OnMessageReceived;
smtpServer.SessionCompleted += OnSessionCompleted;
this.messagesHub = messagesHub;
this.sessionsHub = sessionsHub;
}
public void SmtpClient_NonSSL()
{
DefaultServer server = new DefaultServer(Ports.AssignAutomatically);
server.Start();
SmtpClient client = new SmtpClient("localhost", server.PortNumber);
client.Send("*****@*****.**", "*****@*****.**", "subject", "body");
server.Stop();
}
public async Task MailKit_NonSSL_StressTest()
{
using (DefaultServer server = new DefaultServer(false, StandardSmtpPort.AssignAutomatically))
{
ConcurrentBag <IMessage> messages = new ConcurrentBag <IMessage>();
server.MessageReceivedEventHandler += (o, ea) =>
{
messages.Add(ea.Message);
return(Task.CompletedTask);
};
server.Start();
List <Task> sendingTasks = new List <Task>();
int numberOfThreads = 10;
int numberOfMessagesPerThread = 50;
for (int threadId = 0; threadId < numberOfThreads; threadId++)
{
int localThreadId = threadId;
sendingTasks.Add(Task.Run(async() =>
{
using (MailKit.Net.Smtp.SmtpClient client = new MailKit.Net.Smtp.SmtpClient())
{
await client.ConnectAsync("localhost", server.PortNumber).ConfigureAwait(false);
for (int i = 0; i < numberOfMessagesPerThread; i++)
{
MimeMessage message = NewMessage(i + "@" + localThreadId, "*****@*****.**");
await client.SendAsync(message).ConfigureAwait(false);
}
await client.DisconnectAsync(true).ConfigureAwait(false);
}
}));
}
await Task.WhenAll(sendingTasks).WithTimeout(120, "sending messages").ConfigureAwait(false);
Assert.Equal(numberOfMessagesPerThread * numberOfThreads, messages.Count);
for (int threadId = 0; threadId < numberOfThreads; threadId++)
{
for (int i = 0; i < numberOfMessagesPerThread; i++)
{
Assert.Contains(messages, m => m.Recipients.Any(t => t == i + "@" + threadId));
}
}
}
}
public void StartOnInusePort_StartupExceptionThrown()
{
Server server1 = new DefaultServer(Ports.AssignAutomatically);
server1.Start();
Server server2 = new DefaultServer(server1.PortNumber);
server2.Start();
server1.Stop();
}
public async Task SmtpClient_NonSSL_StressTest()
{
using (DefaultServer server = new DefaultServer(false, Ports.AssignAutomatically))
{
ConcurrentBag <IMessage> messages = new ConcurrentBag <IMessage>();
server.MessageReceived += (o, ea) =>
{
messages.Add(ea.Message);
};
server.Start();
List <Task> sendingTasks = new List <Task>();
int numberOfThreads = 10;
int numberOfMessagesPerThread = 50;
for (int threadId = 0; threadId < numberOfThreads; threadId++)
{
int localThreadId = threadId;
sendingTasks.Add(Task.Run(async() =>
{
using (SmtpClient client = new SmtpClient())
{
await client.ConnectAsync("localhost", server.PortNumber);
for (int i = 0; i < numberOfMessagesPerThread; i++)
{
MimeMessage message = NewMessage(i + "@" + localThreadId);
await client.SendAsync(message);
;
}
await client.DisconnectAsync(true);
}
}));
}
await Task.WhenAll(sendingTasks).WithTimeout(120, "sending messages");
Assert.Equal(numberOfMessagesPerThread * numberOfThreads, messages.Count);
for (int threadId = 0; threadId < numberOfThreads; threadId++)
{
for (int i = 0; i < numberOfMessagesPerThread; i++)
{
Assert.Contains(messages, m => m.To.Any(t => t == i + "@" + threadId));
}
}
}
}
public void SmtpClient_NonSSL()
{
DefaultServer server = new DefaultServer(Ports.AssignAutomatically);
server.Start();
SmtpClient client = new SmtpClient("localhost", server.PortNumber);
client.Send("*****@*****.**", "*****@*****.**", "subject", "body");
server.Stop();
}
public FormMain()
{
InitializeComponent();
Rectangle workingArea = Screen.GetWorkingArea(this);
this.Location = new Point(workingArea.Right - Size.Width, workingArea.Bottom - Size.Height);
server = new DefaultServer(25);
server.SessionStarted += new EventHandler <SessionEventArgs>(this.Server_SessionStarted);
server.SessionCompleted += new EventHandler <SessionEventArgs>(this.Server_SessionCompleted);
server.MessageReceived += new EventHandler <MessageEventArgs>(this.Server_MessageRecieved);
server.MessageCompleted += new EventHandler <MessageEventArgs>(this.Server_MessageCompleted);
StartServer();
}
/// <summary>
///
/// </summary>
/// <param name="server">The server<see cref="DefaultServer"/></param>
/// <param name="toAddress">The toAddress<see cref="string"/></param>
/// <returns>A <see cref="Task{T}"/> representing the async operation</returns>
private async Task SendMessage_MailKit_Async(DefaultServer server, string toAddress, string fromAddress = "*****@*****.**")
{
MimeMessage message = NewMessage(toAddress, fromAddress);
using (MailKit.Net.Smtp.SmtpClient client = new MailKit.Net.Smtp.SmtpClient(new SmtpClientLogger(this.output)))
{
await client.ConnectAsync("localhost", server.PortNumber).ConfigureAwait(false);
await client.SendAsync(new FormatOptions { International = true }, message).ConfigureAwait(false);
await client.DisconnectAsync(true).ConfigureAwait(false);
}
}
private static async Task SendMessageAsync(DefaultServer server, string toAddress)
{
MimeMessage message = NewMessage(toAddress);
using (SmtpClient client = new SmtpClient())
{
await client.ConnectAsync("localhost", server.PortNumber);
await client.SendAsync(message);
await client.DisconnectAsync(true);
}
}
private static CommandResult CopyrightCommandHandler(DefaultServer server, Client sender, string command,
IList <string> args)
{
// As per legal requirements, this shall not be removed or changed!
// As per legal requirements, this shall not be removed or changed!
// As per legal requirements, this shall not be removed or changed!
sender.SendChatMessage($"Drift City Neo City v{Shared.Util.Version.GetVersion()} Copyright 2016 GigaToni");
return(CommandResult.Okay);
// As per legal requirements, this shall not be removed or changed!
// As per legal requirements, this shall not be removed or changed!
// As per legal requirements, this shall not be removed or changed!
}
private static CommandResult ToggleGmStatusCommandHandler(DefaultServer server, Client sender, string command,
IList <string> args)
{
sender.User.GmFlag = !sender.User.GmFlag;
var status = "invisible";
if (sender.User.GmFlag)
{
status = "visible";
}
sender.SendChatMessage($"Your GM Status is now: {status}");
return(CommandResult.Okay);
}
public void StartOnInusePort_StartupExceptionThrown()
{
using (Server server1 = new DefaultServer(false, Ports.AssignAutomatically))
{
server1.Start();
using (Server server2 = new DefaultServer(false, server1.PortNumber))
{
Assert.Throws <SocketException>(() =>
{
server2.Start();
});
}
}
}
private static void Main(string[] args)
{
List <IMessage> messages = new List <IMessage>();
DefaultServer server = new DefaultServer(Ports.AssignAutomatically);
server.MessageReceived += (s, ea) => messages.Add(ea.Message);
server.Start();
int portnumber = server.PortNumber;
//do something to send mail
server.Stop();
}
public MimeMessageBuilderTests()
{
var options = new MimeMessageOptions {
MessageIdDomainPart = MessageIdDomainPart
};
builder = new MimeMessageBuilder(Options.Create(options));
messages = new List <IMessage>();
smtpServer = new DefaultServer(false, SMTP_PORT);
smtpServer.MessageReceivedEventHandler += (o, ea) => {
messages.Add(ea.Message);
return(Task.CompletedTask);
};
smtpServer.Start();
}
public void StartOnInusePort_StartupExceptionThrown()
{
using (Server server1 = new DefaultServer(false, Ports.AssignAutomatically))
{
server1.Start();
using (Server server2 = new DefaultServer(false, server1.PortNumber))
{
Assert.Throws<SocketException>(() =>
{
server2.Start();
});
}
}
}
private void startServer()
{
smtpServer = new DefaultServer(false, options.Port);
messages = new List <IMessage>();
smtpServer.MessageReceivedEventHandler += (o, ea) => {
messages.Add(ea.Message);
return(Task.CompletedTask);
};
smtpServer.AuthenticationCredentialsValidationRequiredEventHandler += (o, ea) => {
ea.AuthenticationResult = this.authenticationResult ?? AuthenticationResult.Success;
return(Task.CompletedTask);
};
smtpServer.Start();
}
public MessageDrivenPublisher()
{
var template = new DefaultServer
{
TransportConfiguration = new ConfigureEndpointAcceptanceTestingTransport(false, true),
PersistenceConfiguration = new ConfigureEndpointAcceptanceTestingPersistence()
};
EndpointSetup(template, (c, _) => c.OnEndpointSubscribed <Context>((args, context) =>
{
if (args.MessageType.Contains(typeof(TestEvent).FullName))
{
context.ReceivedSubscription = true;
}
}));
}
public PublishingEndpoint()
{
var template = new DefaultServer();
template.TransportConfiguration = new ConfigureEndpointAcceptanceTestingTransport(false, true);
// publisher requires a subscription storage
template.PersistenceConfiguration = new ConfigureEndpointLearningPersistence(true);
EndpointSetup(template, (endpoint, _) => endpoint.OnEndpointSubscribed <Context>((args, context) =>
{
if (args.MessageType.Contains(typeof(TestEvent).FullName))
{
context.ReceivedSubscription = true;
}
}));
}
private static CommandResult ExpCommandHandler(DefaultServer server, Client sender, string command,
IList <string> args)
{
if (args.Count < 2)
{
return(CommandResult.InvalidArgument);
}
var characterName = args[0];
int amount;
if (!int.TryParse(args[1], out amount))
{
return(CommandResult.InvalidArgument);
}
if (amount <= 0) // Allow only positive numbers
{
return(CommandResult.InvalidArgument);
}
var client = GameServer.Instance.Server.GetClient(characterName);
// Client / Character is not online! (This activeChar check is redundant, see GetClient(characterName)
if (client?.User.ActiveCharacter == null)
{
return(CommandResult.Fail);
}
bool levelUp;
bool useBonus = false;
bool useBonus500Mita = false;
client.User.ActiveCharacter.CalculateExp(amount, out levelUp, useBonus, useBonus500Mita);
// TODO: Check if user has leveled up, if so send levelup packet!
CharacterModel.Update(GameServer.Instance.Database.Connection, client.User.ActiveCharacter);
sender.SendChatMessage($"{amount} EXP given to {characterName} ({client.User.Username})");
client.Send(new CharUpdateAnswer()
{
Character = client.User.ActiveCharacter
}.CreatePacket());
return(CommandResult.Okay);
}
/// <summary>
/// Loads all necessary components and starts the server.
/// </summary>
public void Run()
{
if (_running)
{
throw new Exception("Server is already running.");
}
int x, y, width, height;
Win32.GetWindowPosition(out x, out y, out width, out height);
Win32.SetWindowPosition(width + 5, height + 5, width, height);
ConsoleUtil.WriteHeader($"Area Server ({Shared.Util.Version.GetVersion()})", ConsoleColor.DarkGreen);
ConsoleUtil.LoadingTitle();
Log.Info("Server startup requested");
Log.Info($"Server Version {Shared.Util.Version.GetVersion()}");
NavigateToRoot();
// Conf
LoadConf(Config = new AreaConf());
// Database
InitDatabase(Database = new AreaDatabase(), Config);
// Start
Server = new DefaultServer(Config.Area.Port, false);
Server.Start();
var server2 = new DefaultServer(11041, false);
server2.Start();
ConsoleUtil.RunningTitle();
_running = true;
Log.Info("Registering commands...");
// Commands
var commands = new AreaConsoleCommands();
commands.Wait();
Log.Info("Finished starting up server!");
}
public EndpointWithDisabledPublishing()
{
var template = new DefaultServer
{
TransportConfiguration = new ConfigureEndpointAcceptanceTestingTransport(false, true)
};
EndpointSetup(
template,
(c, _) =>
{
// DisablePublishing API is only available on the message-driven pub/sub transport settings.
var routingSettings = new RoutingSettings <AcceptanceTestingTransport>(c.GetSettings());
routingSettings.DisablePublishing();
},
pm => pm.RegisterPublisherFor <TestEvent>(typeof(MessageDrivenPublisher)));
}
