protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
while (!stoppingToken.IsCancellationRequested)
{
_logger.LogInformation("Worker running at: {time}", DateTimeOffset.Now);
IConfiguration config = new ConfigurationBuilder()
.AddJsonFile("appsettings.json", true, true)
.AddEnvironmentVariables()
.Build();
var port = int.Parse(config.GetSection("Port").Value);
var options = new SmtpServerOptionsBuilder()
.ServerName("localhost")
.Port(port)
.MessageStore(new LupusMessageStore(config, _logger))
.Build();
_logger.LogInformation($"Starting SMTP server on port {port}");
var smtpServer = new SmtpServer.SmtpServer(options);
await smtpServer.StartAsync(stoppingToken);
}
}
public static void Run()
{
// this is important when dealing with a certificate that isnt valid
ServicePointManager.ServerCertificateValidationCallback = IgnoreCertificateValidationFailureForTestingOnly;
var cancellationTokenSource = new CancellationTokenSource();
var options = new SmtpServerOptionsBuilder()
.ServerName("SmtpServer SampleApp")
.Certificate(CreateCertificate())
.AllowUnsecureAuthentication(false)
.UserAuthenticator(new SampleUserAuthenticator())
.Port(9025, true)
.Build();
var server = new SmtpServer.SmtpServer(options);
server.SessionCreated += OnSessionCreated;
var serverTask = server.StartAsync(cancellationTokenSource.Token);
SampleMailClient.Send(user: "******", password: "******", useSsl: true);
cancellationTokenSource.Cancel();
serverTask.WaitWithoutException();
}
public static void Run()
{
var cancellationTokenSource = new CancellationTokenSource();
var options = new SmtpServerOptionsBuilder()
.ServerName("SmtpServer SampleApp")
.Port(9025)
.MailboxFilter(new SampleMailboxFilter(TimeSpan.FromSeconds(5)))
.Build();
var server = new SmtpServer.SmtpServer(options);
server.SessionCreated += OnSessionCreated;
server.SessionCompleted += OnSessionCompleted;
server.SessionFaulted += OnSessionFaulted;
server.SessionCancelled += OnSessionCancelled;
var serverTask = server.StartAsync(cancellationTokenSource.Token);
// ReSharper disable once MethodSupportsCancellation
Task.Run(() => SampleMailClient.Send());
Console.WriteLine("Press any key to cancel the server.");
Console.ReadKey();
Console.WriteLine("Forcibily cancelling the server and any active sessions");
cancellationTokenSource.Cancel();
serverTask.WaitWithoutException();
Console.WriteLine("The server has been cancelled.");
}
public static void Run()
{
_cancellationTokenSource = new CancellationTokenSource();
var options = new SmtpServerOptionsBuilder()
.ServerName("SmtpServer SampleApp")
.Endpoint(builder =>
builder
.AllowUnsecureAuthentication()
.AuthenticationRequired()
.Port(9025))
.Build();
var serviceProvider = new ServiceProvider();
serviceProvider.Add(new AuthenticationHandler());
var server = new SmtpServer.SmtpServer(options, serviceProvider);
server.SessionCreated += OnSessionCreated;
server.SessionCompleted += OnSessionCompleted;
var serverTask = server.StartAsync(_cancellationTokenSource.Token);
SampleMailClient.Send(user: "******", password: "******", count: 5);
serverTask.WaitWithoutException();
}
static async Task Main(string[] args)
{
//CustomEndpointListenerExample.Run();
ServicePointManager.ServerCertificateValidationCallback = SmtpServerTests.IgnoreCertificateValidationFailureForTestingOnly;
//var options = new SmtpServerOptionsBuilder()
// .ServerName("SmtpServer SampleApp")
// .Port(587, false)
// //.Certificate(SmtpServerTests.CreateCertificate())
// .Build();
var options = new SmtpServerOptionsBuilder()
.ServerName("SmtpServer SampleApp")
.Endpoint(endpoint =>
endpoint
.Port(587)
.AllowUnsecureAuthentication(true)
.AuthenticationRequired(false))
.UserAuthenticator(new SampleUserAuthenticator())
//.Certificate(SmtpServerTests.CreateCertificate())
.Build();
var server = new SmtpServer.SmtpServer(options);
server.SessionCreated += OnSessionCreated;
server.SessionCompleted += OnSessionCompleted;
server.SessionFaulted += OnSessionFaulted;
var serverTask = server.StartAsync(CancellationToken.None);
Console.ReadKey();
await serverTask.ConfigureAwait(false);
}
public static void Run()
{
var cancellationTokenSource = new CancellationTokenSource();
var options = new SmtpServerOptionsBuilder()
.ServerName("SmtpServer SampleApp")
.Certificate(CreateCertificate())
.Endpoint(builder =>
builder
.Port(9025, true)
.AllowUnsecureAuthentication(false))
.Build();
var serviceProvider = new ServiceProvider();
serviceProvider.Add(new CustomEndpointListenerFactory());
var server = new SmtpServer.SmtpServer(options, serviceProvider);
var serverTask = server.StartAsync(cancellationTokenSource.Token);
SampleMailClient.Send(useSsl: true);
cancellationTokenSource.Cancel();
serverTask.WaitWithoutException();
}
private async void Start_Click(object sender, EventArgs e)
{
EnableDisable(false);
TimeSpan seconds =
TimeSpan.FromSeconds(Decimal.ToDouble(timeout.Value));
LoggingMessageStore store = new LoggingMessageStore();
store.Message += Store_Message;
ISmtpServerOptions options = new OptionsBuilder()
.ServerName(serverName.Text)
.Port(Decimal.ToInt32(port.Value))
.CommandWaitTimeout(seconds)
.MessageStore(store)
.Build();
smtpServer = new SmtpServer.SmtpServer(options);
smtpServer.SessionCreated += OnSessionCreated;
try
{
cancellationTokenSource = new CancellationTokenSource();
await smtpServer.StartAsync(cancellationTokenSource.Token)
.ConfigureAwait(true);
}
catch (SocketException ex)
{
MessageBox.Show(this, ex.Message, this.Text);
}
catch (OperationCanceledException)
{
// nothing for user to do
}
EnableDisable(true);
}
public async void Start()
{
_cancellationTokenSource = new CancellationTokenSource();
var telegramSettings = TelegramConfiguration.Read();
var telegramAsMessageStore = new TelegramAsMessageStore(telegramSettings.Token, telegramSettings.ChatId);
var smtpSettings = SmtpConfiguration.Read();
var options = new SmtpServerOptionsBuilder()
.Port(smtpSettings.Port)
.Build();
var serviceProvider = new ServiceProvider();
serviceProvider.Add(telegramAsMessageStore);
var smtpServer = new SmtpServer.SmtpServer(options, serviceProvider);
_ = new SmtpSessionLogger(smtpServer, _log);
await smtpServer.StartAsync(_cancellationTokenSource.Token);
if (Environment.UserInteractive)
{
_log.Warn($"{ServiceName} started in interactive mode");
}
else
{
_log.Warn($"{ServiceName} service started");
}
}
public static async Task Main(string[] args)
{
var config = new ConfigurationBuilder()
.AddEnvironmentVariables()
.SetBasePath(PlatformServices.Default.Application.ApplicationBasePath)
.AddJsonFile($"appsettings.{Environment.UserName}.json", true)
.AddJsonFile("appsettings.Development.json", true)
.AddJsonFile("appsettings.json")
.Build();
var serviceProvider = BootstrapDependencyInjection(config);
var hangfireOptions = serviceProvider.GetHangfireOptionsOrDefault();
var hangfireJobStorage = CreateRedisJobStorage(hangfireOptions);
using (var server = CreateHangfireBackgroundJobServer(hangfireJobStorage, new HangfireActivator(serviceProvider)))
{
var smtpOptions = serviceProvider.GetSmtpOptionsOrDefault();
var backgroundJobClient = new BackgroundJobClient(hangfireJobStorage);
var options = new OptionsBuilder()
.ServerName(smtpOptions.HostName)
.Port(smtpOptions.Port)
.MessageStore(new RedisMinioMailStore(backgroundJobClient))
.Build();
var smtpServer = new SmtpServer.SmtpServer(options);
await smtpServer.StartAsync(CancellationToken.None);
server.SendStop();
}
}
public Worker(MessageStore messageStore)
{
smtpServer = new SmtpServer.SmtpServer(new SmtpServerOptionsBuilder()
.ServerName("localhost")
.Port(25)
.MessageStore(messageStore)
.Build());
}
public SmtpSessionLogger(SmtpServer.SmtpServer server, Logger logger)
{
server.SessionCreated += OnSessionCreated;
server.SessionCompleted += OnSessionCompleted;
server.SessionFaulted += OnSessionFaulted;
server.SessionCancelled += OnSessionCancelled;
_log = logger;
}
private async Task StartSmtpServer(string host, int port)
{
var options = new SmtpServerOptionsBuilder()
.ServerName(host)
.Port(port)
.MessageStore(new SmtpForMeMessageStore())
.Build();
var smtpServer = new SmtpServer.SmtpServer(options);
await smtpServer.StartAsync(CancellationToken.None);
}
public async Task StartAsync(CancellationToken cancellationToken)
{
var options = new SmtpServerOptionsBuilder()
.ServerName("localhost")
.Port(25, 587)
.MessageStore(new RadishMessageStore(queueService))
.Build();
server = new SmtpServer.SmtpServer(options);
await server.StartAsync(cancellationToken);
}
static async Task RunServerAsync(ISmtpServerOptions options, CancellationToken cancellationToken)
{
var smtpServer = new SmtpServer.SmtpServer(options);
smtpServer.SessionCreated += OnSmtpServerSessionCreated;
smtpServer.SessionCompleted += OnSmtpServerSessionCompleted;
await smtpServer.StartAsync(cancellationToken);
smtpServer.SessionCreated -= OnSmtpServerSessionCreated;
smtpServer.SessionCompleted -= OnSmtpServerSessionCompleted;
}
static async Task RunServerAsync(ISmtpServerOptions options, CancellationToken cancellationToken)
{
var smtpServer = new SmtpServer.SmtpServer(options);
smtpServer.SessionCreated += OnSmtpServerSessionCreated;
smtpServer.SessionCompleted += OnSmtpServerSessionCompleted;
await smtpServer.StartAsync(cancellationToken);
smtpServer.SessionCreated -= OnSmtpServerSessionCreated;
smtpServer.SessionCompleted -= OnSmtpServerSessionCompleted;
}
private void StartEmailServer()
{
var options = new SmtpServerOptionsBuilder()
.ServerName("localhost")
.Port(smtpPort)
.MessageStore(new SampleMessageStore())
.Build();
var smtpServer = new SmtpServer.SmtpServer(options);
smtpServer.StartAsync(CancellationToken.None);
}
public SmtpServer()
{
_messageStore = new MessageStore();
var options = new OptionsBuilder()
.ServerName("localhost")
.Port(25)
.MessageStore(_messageStore)
.Build();
_tokenSource = new CancellationTokenSource();
_smtpServer = new SmtpServer2(options);
}
public async void StartServer()
{
var options = new SmtpServerOptionsBuilder()
.ServerName("localhost")
.Port(25, 587)
.MessageStore(new MS())
.MailboxFilter(new MF())
.UserAuthenticator(new UA())
.Build();
var smtpServer = new SmtpServer.SmtpServer(options);
await smtpServer.StartAsync(CancellationToken.None);
}
public async Task <bool> Run(CancellationToken token, Logger log)
{
var options = new SmtpServerOptionsBuilder()
.ServerName("localhost")
.Port(25, 587)
.MessageStore(new MessageStore())
.Build();
var smtpServer = new SmtpServer.SmtpServer(options);
await smtpServer.StartAsync(token);
return(true);
}
private static async Task StartAsync()
{
var smtpOptions = new OptionsBuilder()
.ServerName("localhost")
.Port(4001)
.MessageStore(new MessageStoreFactory())
.MailboxFilter(new MailboxFilterFactory())
.UserAuthenticator(new UserAuthenticator())
.Build();
var smtpServer = new SmtpServer.SmtpServer(smtpOptions);
await smtpServer.StartAsync(CancellationToken.None);
}
/// <summary>
/// Initializes a new instance of the Listener
/// </summary>
/// <param name="cancellationToken">The Cancellation Token to stop a transaction</param>
/// <returns>An awaitable <see cref="Task"/> with the listener to Smtp Messages</returns>
public async Task StartAsync(CancellationToken cancellationToken)
{
// Parameters for the SMTP Server
ISmtpServerOptions options;
// Setup the MessageStore
SmtpMessageStore smtpMessageStore = new SmtpMessageStore();
smtpMessageStore.MessageReceived += SmtpMessageStore_MessageReceived;
smtpMessageStore.MessageReceivedWithErrors += SmtpMessageStore_MessageReceivedWithErrors;
// Configure the SMTP Server Parameters
if (this.RequiresAuthentication)
{
// Setup the UserAuthenticator
SmtpAuthenticator smtpAuthenticator = new SmtpAuthenticator();
options = new SmtpServerOptionsBuilder().ServerName(this.ServerName)
.Port(this.Ports)
.AllowUnsecureAuthentication(!this.UseSSL)
.AuthenticationRequired(true)
.MessageStore(smtpMessageStore)
.UserAuthenticator(smtpAuthenticator)
.Build();
}
else
{
options = new SmtpServerOptionsBuilder().ServerName(this.ServerName)
.Port(this.Ports)
.AllowUnsecureAuthentication(!this.UseSSL)
.AuthenticationRequired(false)
.MessageStore(smtpMessageStore)
.Build();
}
// Initialize the SMTP Server
Server = new SmtpServer.SmtpServer(options);
// Hook the events
Server.SessionCreated += Server_OnSessionCreated;
Server.SessionCompleted += Server_OnSessionCompleted;
// Sets the Listening to on and kick event
IsListening = true;
ListeningStarted?.Invoke(this, null);
// Starts the SMTP Server
await Server.StartAsync(cancellationToken);
}
public Task StartAsync(CancellationToken cancellationToken)
{
var mailServiceProvider = new ServiceProvider();
mailServiceProvider.Add(this.messageStore);
mailServiceProvider.Add(this.serviceProvider.Resolve <MailboxFilter>());
this.smtpServer = new SmtpServer.SmtpServer(this.options, mailServiceProvider);
this.smtpServer.SessionCreated += this.SmtpServer_SessionCreated;
this.smtpServer.SessionFaulted += this.SmtpServer_SessionFaulted;
this.smtpServer.SessionCompleted += this.SmtpServer_SessionCompleted;
_ = this.smtpServer.StartAsync(CancellationToken.None);
return(Task.CompletedTask);
}
private static SmtpServer.SmtpServer CreateSmtpServer(MessageStore store)
{
var userAuthenticator = new UserAuthenticator("user1", "myPassw0rd");
var options = new OptionsBuilder()
.ServerName("localhost")
.Port(25, 587)
.MessageStore(store)
.AllowUnsecureAuthentication(false)
.UserAuthenticator(userAuthenticator)
.Build();
var smtpServer = new SmtpServer.SmtpServer(options);
return(smtpServer);
}
static async Task Main(string[] args)
{
System.Console.WriteLine("Resgrid Email Processor");
System.Console.WriteLine("-----------------------------------------");
Prime();
var options = new SmtpServerOptionsBuilder()
.ServerName("localhost")
.Port(25, 587)
.MessageStore(new SampleMessageStore())
.Build();
var smtpServer = new SmtpServer.SmtpServer(options);
await smtpServer.StartAsync(CancellationToken.None);
}
public async Task Run()
{
int[] ports = this.ports.Split(",").Select(p => int.Parse(p)).ToArray();
SslProtocols sslProtocols = (SslProtocols)Enum.Parse(typeof(SslProtocols), this.sslProtocols);
var optionsBuilder = new SmtpServerOptionsBuilder()
.ServerName(this.serverName);
foreach (int port in ports)
{
optionsBuilder.Endpoint(builder =>
{
builder
.AllowUnsecureAuthentication()
.AuthenticationRequired()
.Port(port);
if (secure)
{
// this is important when dealing with a certificate that isnt valid
ServicePointManager.ServerCertificateValidationCallback = IgnoreCertificateValidationFailureForTestingOnly;
builder.Certificate(CreateCertificate(this.certificateFilePath, this.certificatePasswordFilePath));
}
});
}
var sp = new SmtpServer.ComponentModel.ServiceProvider();
sp.Add(new MailDamMessageStore());
sp.Add(new MailDamMailboxFilter());
sp.Add(new MailDamUserAuthenticator());
var options = optionsBuilder.Build();
var smtpServer = new SmtpServer.SmtpServer(options, sp);
smtpServer.SessionCreated += OnSessionCreated;
smtpServer.SessionCompleted += OnSessionCompleted;
smtpServer.SessionFaulted += OnSessionFaulted;
smtpServer.SessionCancelled += OnSessionCancelled;
await smtpServer.StartAsync(CancellationToken.None);
}
MailListener mailListener = new MailListener("localhost", 25); // Listens for incoming mails.
// "var" keyword as well as INITIALIZING WON'T WORK IN CLASS DEFINITION.
private void StartSmtp()
{
var options = new OptionsBuilder()
.WithServerName("localhost")
.WithPort(25, 587)
.WithMessageStore(new ConsoleMessageStore())
//.WithMailboxFilter(new MailboxFilter())
//.WithUserAuthenticator(new UserAuthenticator())
.Build();
var smtpServer = new SmtpServer(options);
smtpServer.StartAsync(CancellationToken.None);
//await smtpServer.StartAsync(CancellationToken.None);*/
}
private static SmtpServer.SmtpServer CreateSmtpServer(MessageStore store)
{
// ReSharper disable once StringLiteralTypo
var userAuthenticator = new UserAuthenticator("user1", "myPassw0rd");
IUserAuthenticatorFactory userAuthenticatorFactory = new UserAuthenticatorFactory(userAuthenticator);
var options = new SmtpServerOptionsBuilder()
.ServerName("localhost")
.Port(25, 587)
.MessageStore(store)
.UserAuthenticator(userAuthenticatorFactory)
.Build();
var smtpServer = new SmtpServer.SmtpServer(options);
return(smtpServer);
}
public static void Run()
{
var cancellationTokenSource = new CancellationTokenSource();
var options = new OptionsBuilder()
.ServerName("SmtpServer SampleApp")
.Port(9025)
.Build();
var server = new SmtpServer.SmtpServer(options);
var serverTask = server.StartAsync(cancellationTokenSource.Token);
SampleMailClient.Send();
cancellationTokenSource.Cancel();
serverTask.WaitWithoutException();
}
public static void Run()
{
var cancellationTokenSource = new CancellationTokenSource();
var options = new SmtpServerOptionsBuilder()
.ServerName("SmtpServer SampleApp")
.Port(9025)
//.Endpoint(new EndpointDefinitionBuilder().Endpoint(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 9025)).Build())
.Build();
var server = new SmtpServer.SmtpServer(options);
var serverTask = server.StartAsync(cancellationTokenSource.Token);
SampleMailClient.Send();
cancellationTokenSource.Cancel();
serverTask.WaitWithoutException();
}
public SmtpListener(IServiceScopeFactory scopeFactory, IOptions <ServerDefaults> serverDefaults)
{
_scopeFactory = scopeFactory;
_serverDefaults = serverDefaults.Value;
var options = new OptionsBuilder()
.ServerName("localhost")
.Port(GetSmtpPorts())
.AuthenticationRequired(false)
.AllowUnsecureAuthentication(true)
.UserAuthenticator(new AuthFactory())
.MessageStore(new SmtpMessageStore())
.Build();
smtpServer = new SmtpServer.SmtpServer(options);
smtpServer.SessionCreated += SmtpServer_SessionCreated;
smtpServer.SessionCompleted += SmtpServer_SessionCompleted;
}
public AuthServiceTest() : base()
{
var configuration = new ConfigurationBuilder()
.AddJsonFile("appsettings.json")
.Build();
var options = new OptionsBuilder()
.ServerName(configuration["Mailer:Server"])
.Port(int.Parse(configuration["Mailer:Port"]))
.MessageStore(_messageStore)
.AllowUnsecureAuthentication()
.UserAuthenticator(new SampleUserAuthenticatorFactory())
.Build();
var smtpServer = new SmtpServer.SmtpServer(options);
Task.Run(() => smtpServer.StartAsync(CancellationToken.None));
}
public static void Run()
{
_cancellationTokenSource = new CancellationTokenSource();
var options = new SmtpServerOptionsBuilder()
.ServerName("SmtpServer SampleApp")
.Port(9025)
.Build();
var server = new SmtpServer.SmtpServer(options, ServiceProvider.Default);
server.SessionCreated += OnSessionCreated;
server.SessionCompleted += OnSessionCompleted;
var serverTask = server.StartAsync(_cancellationTokenSource.Token);
SampleMailClient.Send();
serverTask.WaitWithoutException();
}
