public QueueHelper(QueueSettings settings)
{
_settings = settings;
var factory = new ConnectionFactory()
{
HostName = _settings.QueueEndpoint
};
_connection = factory.CreateConnection();
_channel = _connection.CreateModel();
}
protected Task SendMessage <T>(QueueSettings queueSettings, T message, DateTime?scheduledTime = null) where T : class
{
try
{
return(BasePublisher.SendMessage(queueSettings,
message, scheduledTime));
}
catch (Exception e)
{
throw new Exception("BaseController.SendMessage : " + e.Message);
}
}
public void ShouldSetPollingTimeoutMillisecondsFromConstructor()
{
//arrange and act
const int pollingTimeoutMilliseconds = 11000;
var settings = new QueueSettings("x",
new ApplicationConfiguration {
PollingTimeoutMilliseconds = pollingTimeoutMilliseconds
});
var queueSettings = settings;
//assert
queueSettings.PollingTimeoutMilliseconds.Should().Be(pollingTimeoutMilliseconds);
}
public void ShouldSetRabbitManagementWebUrlWhenPortIsDefault()
{
//arrange and act
const string rabbitConnectionString = "http://host:99";
var settings = new QueueSettings("x",
new ApplicationConfiguration {
RabbitConnectionString = rabbitConnectionString
});
var queueSettings = settings;
//assert
queueSettings.RabbitManagementWebUrl.Should().Be("http://host:15672");
}
public void ShouldSetRabbitConnectionStringFromConstructor()
{
//arrange and act
const string rabbitConnectionString = "one";
var settings = new QueueSettings("x",
new ApplicationConfiguration {
RabbitConnectionString = rabbitConnectionString
});
var queueSettings = settings;
//assert
queueSettings.RabbitConnectionString.Should().Be(rabbitConnectionString);
}
/// <summary>
/// Applies queue settings specified within the application's configuration
/// to the queue metadata. Only values specified are set.
/// </summary>
/// <param name="settings">External stored exchange settings.</param>
public void ApplyOverrides(QueueSettings settings)
{
IsPassive = settings.Passive ?? IsPassive;
RouteKeys = settings.RouteKeys ?? RouteKeys;
PrefetchCount = settings.PrefetchCount ?? PrefetchCount;
MaxPriority = settings.MaxPriority;
Priority = settings.Priority ?? Priority;
DeadLetterExchange = settings.DeadLetterExchange ?? DeadLetterExchange;
DeadLetterRoutingKey = settings.DeadLetterRoutingKey ?? DeadLetterRoutingKey;
PerQueueMessageTtl = settings.PerQueueMessageTtl ?? PerQueueMessageTtl;
}
public void ShouldSetHeartbeatIntervalSecondsFromConstructor()
{
//arrange and act
const int heartbeatIntervalSeconds = 11000;
var settings = new QueueSettings("x",
new ApplicationConfiguration {
HeartbeatIntervalSeconds = heartbeatIntervalSeconds
});
var queueSettings = settings;
//assert
queueSettings.HeartbeatIntervalSeconds.Should().Be(heartbeatIntervalSeconds);
}
public static IServiceCollection RegisterConfigurationServices(this IServiceCollection service, HostBuilderContext context)
{
var connectionStrings = new ConnectionStrings();
var queueSettings = new QueueSettings();
context.Configuration.GetSection("ConnectionStrings").Bind(connectionStrings);
context.Configuration.GetSection("QueueSettings").Bind(queueSettings);
service.AddSingleton(connectionStrings);
service.AddSingleton(queueSettings);
return(service);
}
public Producer(QueueSettings queueSettings)
{
if (queueSettings is null)
{
throw new ArgumentNullException(nameof(queueSettings));
}
this.queueName = queueSettings.Queue;
this.exchangeName = queueSettings.Exchange;
this.routingKey = queueSettings.RoutingKey;
this.brokerAddress = queueSettings.BrokerAddress;
this.credentials = queueSettings.Credentials;
}
public static void QueueDeclare(this IModel channel,
string queueName,
QueueSettings settings)
{
Check.NotNull(channel, nameof(channel));
Check.NotNullOrWhiteSpace(queueName, nameof(queueName));
Check.NotNull(settings, nameof(settings));
channel.QueueDeclare(queueName,
settings.IsDurable,
settings.IsExclusive,
settings.IsAutoDelete,
settings.Arguments);
}
private IAmazonSQS CreateAmazonSQSClient(QueueSettings settings)
{
if (string.IsNullOrWhiteSpace(settings.Endpoint))
{
return(new AmazonSQSClient());
}
// local usage
var config = new AmazonSQSConfig {
ServiceURL = settings.Endpoint
};
return(new AmazonSQSClient(config));
}
private void DeclareQueue(IModel channel, QueueSettings settings, string queueName, IDictionary <string, object> queueArgs = null, bool exclusive = false)
{
if (settings.Exclusive)
{
settings.AutoDelete = true;
}
channel.QueueDeclare(
queue: queueName,
durable: settings.IsDurable,
exclusive: exclusive,
autoDelete: settings.AutoDelete,
arguments: queueArgs);
}
public void Initialize()
{
string savePath = _environmentService.AppSettingsPath;
string logPath = Path.GetFullPath(Path.Combine(savePath, ".."));
if (CheckIfPortableMode(AppSettingsFileName))
{
savePath = AppDomain.CurrentDomain.BaseDirectory;
logPath = savePath;
}
Logger.Initialize(logPath, TraceLevel.Verbose);
_appSettings = LoadSettings <AppSettings>(Path.Combine(savePath, AppSettingsFileName));
if (AppSettings.Upgrade(_appSettings))
{
SaveSettings(Path.Combine(GetAppDataPath(), AppSettingsFileName), _appSettings);
}
Logger.ChangeLogLevel((TraceLevel)Enum.Parse(typeof(TraceLevel), _appSettings.LogLevel));
Logger.Information("IsLongPathSupported: {0}", ShellService.IsLongPathSupported);
_queueSettings = LoadSettings <QueueSettings>(Path.Combine(savePath, QueueSettingsFileName));
_managerSettings = LoadSettings <ManagerSettings>(Path.Combine(savePath, ManagerSettingsFileName));
_cookieList = LoadSettings <List <Cookie> >(Path.Combine(savePath, CookiesFileName));
ShellService.Settings = _appSettings;
ShellService.ShowErrorAction = ShellViewModel.ShowError;
ShellService.ShowDetailsViewAction = ShowDetailsView;
ShellService.ShowQueueViewAction = ShowQueueView;
ShellService.UpdateDetailsViewAction = UpdateDetailsView;
ShellService.SettingsUpdatedHandler += OnSettingsUpdated;
ShellService.InitializeOAuthManager();
ManagerController.QueueManager = _queueManager;
ManagerController.ManagerSettings = _managerSettings;
ManagerController.BlogManagerFinishedLoadingLibrary += OnBlogManagerFinishedLoadingLibrary;
QueueController.QueueSettings = _queueSettings;
QueueController.QueueManager = _queueManager;
DetailsController.QueueManager = _queueManager;
CrawlerController.QueueManager = _queueManager;
Task managerControllerInit = ManagerController.InitializeAsync();
QueueController.Initialize();
DetailsController.Initialize();
CrawlerController.Initialize();
_cookieService.SetUriCookie(_cookieList);
}
public void ShouldStoreFactoryInDictionaryByRabbitUri()
{
//arrange
const string rabbitConnectionString = "amqp://localhost2";
var queueSettings = new QueueSettings("queue",
new ApplicationConfiguration {
RabbitConnectionString = rabbitConnectionString
});
var factory = new RabbitConnectionFactory();
//act
factory.Create(queueSettings.RabbitConnectionString, (ushort)queueSettings.HeartbeatIntervalSeconds);
//assert
factory.connectionFactories.ContainsKey(rabbitConnectionString).Should().BeTrue();
}
public void ShouldReuseInstanceOfConnectionFactoryWhenItExists()
{
//arrange
const string rabbitConnectionString = "amqp://localhost2";
var queueSettings = new QueueSettings("queue",
new ApplicationConfiguration {
RabbitConnectionString = rabbitConnectionString
});
var factory = new RabbitConnectionFactory();
var originalInstance = factory.Create(queueSettings.RabbitConnectionString, (ushort)queueSettings.HeartbeatIntervalSeconds);
//act
var secondInstance = factory.Create(queueSettings.RabbitConnectionString, (ushort)queueSettings.HeartbeatIntervalSeconds);
//assert
originalInstance.Should().BeSameAs(secondInstance);
}
private void Initialize(IModel channel, IConnection conn, QueueSettings settings)
{
// create our channels
channel = conn.CreateModel();
// args
Dictionary <String, Object> args = new Dictionary <string, object>();
if (settings.DeadLetters)
{
//dead letter Exchange
string deadLetterEx = $"{settings.Queue}.dead-letter-ex";
DeclareExchange(channel, settings, deadLetterEx);
// dead letter queue
string deadLetterQ = $".dead-letter-q";
DeclareQueue(channel, settings, deadLetterQ, null);
Bind(channel, deadLetterQ, deadLetterEx, settings.RoutingKey);
args.Add("x-dead-letter-exchange", deadLetterEx);
args.Add("x-dead-letter-routing-key", settings.RoutingKey);
}
// create ex
DeclareExchange(channel, settings, settings.Exchange);
// create Queue
//if (_settings.RetryDelay > 0)
//{
// // c.ExchangeDeclare(delayedExchange, "x-delayed-message", true, true, CreateProperty("x-delayed-type", "direct")
// string delayedExchange = $"{_settings.Queue}.delayed";
// args.Add("x-dead-letter-exchange", delayedExchange ?? "");
//}
if (settings.QoS > 0)
{
channel.BasicQos(0, settings.QoS, false);
}
DeclareQueue(channel, settings, settings.Queue, args, settings.Exclusive);
// bind
Bind(channel, settings.Queue, settings.Exchange, settings.RoutingKey);
}
public QueueSubscriber(TMessageProcessor messageProcessor, TQueueSettingsProvider queueSettingsProvider, TMessageDeserializer messageDeserializer, ILogger logger)
{
QueueSettings settings = queueSettingsProvider.Get();
connectionFactory = new ConnectionFactory()
{
HostName = settings.Host
};
connection = connectionFactory.CreateConnection();
channel = connection.CreateModel();
channel.QueueDeclare(queue: settings.QueueName, durable: true, exclusive: false, autoDelete: false, arguments: null);
consumer = new EventingBasicConsumer(channel);
channel.BasicConsume(queue: settings.QueueName, autoAck: false, consumer: consumer);
this.messageProcessor = messageProcessor;
this.queueSettingsProvider = queueSettingsProvider;
this.messageDeserializer = messageDeserializer;
this.logger = logger;
}
protected QueueService(IPersistentConnection persistentConnection,
IOptions <QueueSettings> settings, ILogger <QueueService> logger)
{
Settings = settings?.Value ?? throw new ArgumentNullException(nameof(settings));
_logger =
logger ?? throw new ArgumentNullException(nameof(logger));
_persistentConnection =
persistentConnection ?? throw new ArgumentNullException(nameof(persistentConnection));
_consumerChannel = CreateConsumerChannel();
_producerChannel = CreateProducerChannel();
_basicProperties = new BasicProperties
{
Persistent = true,
DeliveryMode = 2,
ContentType = "application/json",
ContentEncoding = Encoding.UTF8.EncodingName
};
}
public void Initialize()
{
appSettings = LoadSettings <AppSettings>(appSettingsFileName);
queueSettings = LoadSettings <QueueSettings>(queueSettingsFileName);
managerSettings = LoadSettings <ManagerSettings>(managerSettingsFileName);
ShellService.Settings = appSettings;
ShellService.ShowErrorAction = ShellViewModel.ShowError;
ShellService.ShowDetailsViewAction = ShowDetailsView;
ShellService.ShowQueueViewAction = ShowQueueView;
ShellService.InitializeOAuthManager();
ManagerController.QueueManager = queueManager;
ManagerController.ManagerSettings = managerSettings;
ManagerController.Initialize();
QueueController.QueueSettings = queueSettings;
QueueController.QueueManager = queueManager;
QueueController.Initialize();
}
public RbmqQueue(ILoggerFactory loggerFactory, RbmqConfigurationElement settings, bool publisher = true)
{
_logger = loggerFactory.CreateLogger <RbmqQueue>();
// default serialization settings
this._publisherSerializationSettings = new JsonSerializerSettings()
{
Formatting = Formatting.Indented
};
this._consumerSerializationSettings = new JsonSerializerSettings()
{
Formatting = Formatting.Indented
};
if (publisher)
{
_publisherSettings = new QueueSettings(settings);
if (string.IsNullOrEmpty(_publisherSettings.Queue))
{
_publisherSettings.GenerateNewQueueName(true);
_publisherSettings.GeneratedQueueName = true;
_publisherSettings.Exclusive = true;
}
_publishConn = GetConnection(_publisherSettings);
Initialize(_publishChannel, _publishConn, _publisherSettings);
_publishConn.ConnectionShutdown += PublisherConnectionShutdown;
}
else
{
_consumerSettings = new QueueSettings(settings);
if (string.IsNullOrEmpty(_consumerSettings.Queue))
{
_consumerSettings.GenerateNewQueueName(false);
_consumerSettings.GeneratedQueueName = true;
_consumerSettings.Exclusive = true;
}
_consumerConn = GetConnection(_consumerSettings);
Initialize(_consumerChannel, _consumerConn, _consumerSettings);
_consumerConn.ConnectionShutdown += ConsumerConnectionShutdown;
}
}
private void QueueDeclare(IModel model, QueueSettings settings)
{
this.logger.LogInformation($"Declaring queue {settings.QueueName}");
if (settings.Arguments == null)
{
settings.Arguments = new Dictionary <string, object>();
}
if (settings.DeadLetterRoutingKey != null)
{
if (settings.Arguments.Keys.Contains(QUEUE_DEAD_LETTER_ROUTING_KEY_ARGUMENT))
{
settings.Arguments.Remove(QUEUE_DEAD_LETTER_ROUTING_KEY_ARGUMENT);
}
settings.Arguments.Add(QUEUE_DEAD_LETTER_ROUTING_KEY_ARGUMENT, settings.DeadLetterRoutingKey);
// Rabbit will reject routing key only, so default to default exchange
if (!settings.Arguments.Keys.Contains(QUEUE_DEAD_LETTER_EXCHANGE_ARGUMENT))
{
settings.Arguments.Add(QUEUE_DEAD_LETTER_EXCHANGE_ARGUMENT, "");
}
}
if (settings.DeadLetterExchange != null)
{
if (settings.Arguments.Keys.Contains(QUEUE_DEAD_LETTER_EXCHANGE_ARGUMENT))
{
settings.Arguments.Remove(QUEUE_DEAD_LETTER_EXCHANGE_ARGUMENT);
}
settings.Arguments.Add(QUEUE_DEAD_LETTER_EXCHANGE_ARGUMENT, settings.DeadLetterExchange);
}
model.QueueDeclare(
queue: settings.QueueName,
durable: settings.Durable,
exclusive: settings.Exclusive,
autoDelete: settings.AutoDelete,
arguments: settings.Arguments
);
}
public void Initialize()
{
if (CheckIfPortableMode(appSettingsFileName))
{
appSettings = LoadSettings <AppSettings>(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, appSettingsFileName));
queueSettings =
LoadSettings <QueueSettings>(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, queueSettingsFileName));
managerSettings =
LoadSettings <ManagerSettings>(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, managerSettingsFileName));
cookieList = LoadSettings <List <Cookie> >(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, cookiesFileName));
}
else
{
appSettings = LoadSettings <AppSettings>(Path.Combine(environmentService.AppSettingsPath, appSettingsFileName));
queueSettings =
LoadSettings <QueueSettings>(Path.Combine(environmentService.AppSettingsPath, queueSettingsFileName));
managerSettings =
LoadSettings <ManagerSettings>(Path.Combine(environmentService.AppSettingsPath, managerSettingsFileName));
cookieList = LoadSettings <List <Cookie> >(Path.Combine(environmentService.AppSettingsPath, cookiesFileName));
}
ShellService.Settings = appSettings;
ShellService.ShowErrorAction = ShellViewModel.ShowError;
ShellService.ShowDetailsViewAction = ShowDetailsView;
ShellService.ShowQueueViewAction = ShowQueueView;
ShellService.UpdateDetailsViewAction = UpdateDetailsView;
ShellService.InitializeOAuthManager();
ManagerController.QueueManager = queueManager;
ManagerController.ManagerSettings = managerSettings;
ManagerController.BlogManagerFinishedLoadingLibrary += OnBlogManagerFinishedLoadingLibrary;
Task managerControllerInit = ManagerController.Initialize();
QueueController.QueueSettings = queueSettings;
QueueController.QueueManager = queueManager;
QueueController.Initialize();
DetailsController.QueueManager = queueManager;
DetailsController.Initialize();
CrawlerController.QueueManager = queueManager;
CrawlerController.Initialize();
cookieService.SetUriCookie(cookieList);
}
static void Main(string[] args)
{
string senderName;
QueueSettings settings = new QueueSettings()
{
Queue = "LittleRabbit",
Exchange = "MyLittleExchange",
RoutingKey = "TheRoutingKey",
BrokerAddress = "192.168.0.133:5672",
Credentials = new QueueCredentials()
{
User = "******",
Password = "******"
}
};
var sender = new Producer(settings);
string input;
Console.Write("Please introduce yourself: ");
senderName = Console.ReadLine();
Console.WriteLine($"Hello {senderName}, write a message to send it to the queue");
Console.WriteLine("Type q to quit");
while (true)
{
Console.Write("Write a message: ");
input = Console.ReadLine();
if (input == "q")
{
break;
}
sender.Send(input, senderName);
}
Console.WriteLine("Ok, I'm done.");
}
public static IServiceCollection RegisterQueueServices(this IServiceCollection services, HostBuilderContext context)
{
var queueSettings = new QueueSettings();
context.Configuration.GetSection("QueueSettings").Bind(queueSettings);
services.AddMassTransit(c =>
{
c.AddConsumer <ProductChangedConsumer>();
});
services.AddSingleton(provider => Bus.Factory.CreateUsingRabbitMq(cfg =>
{
var host = cfg.Host(queueSettings.HostName, queueSettings.VirtualHost, h => {
h.Username(queueSettings.UserName);
h.Password(queueSettings.Password);
});
cfg.SetLoggerFactory(provider.GetService <ILoggerFactory>());
}));
return(services);
}
private void SaveList()
{
FileDialogResult result = fileDialogService.ShowSaveFileDialog(shellService.ShellView, saveQueuelistFileType);
if (!result.IsValid)
{
return;
}
var queueList = new QueueSettings();
queueList.ReplaceAll(QueueManager.Items.Select(item => item.Blog.Name).ToList(),
QueueManager.Items.Select(item => item.Blog.BlogType).ToList());
try
{
string targetFolder = Path.GetDirectoryName(result.FileName);
string name = Path.GetFileNameWithoutExtension(result.FileName);
using (
var stream = new FileStream(Path.Combine(targetFolder, name) + ".que", FileMode.Create, FileAccess.Write,
FileShare.None))
{
using (var writer = JsonReaderWriterFactory.CreateJsonWriter(
stream, Encoding.UTF8, true, true, " "))
{
var serializer = new DataContractJsonSerializer(typeof(QueueSettings));
serializer.WriteObject(writer, queueList);
writer.Flush();
}
}
}
catch (Exception ex)
{
Logger.Error("QueueController:SaveList: {0}", ex);
shellService.ShowError(ex, Resources.CouldNotSaveQueueList);
}
}
static void Main()
{
QueueSettings settings = new QueueSettings()
{
Queue = "LittleRabbit",
Exchange = "MyLittleExchange",
RoutingKey = "TheRoutingKey",
BrokerAddress = "192.168.0.133:5672",
Credentials = new QueueCredentials()
{
User = "******",
Password = "******"
}
};
Console.WriteLine("Started Receiver");
ReceiverWorker receiver = new ReceiverWorker(settings);
receiver.Work();
Console.ReadLine();
}
public void Initialize()
{
string savePath = _environmentService.AppSettingsPath;
if (CheckIfPortableMode(AppSettingsFileName))
{
savePath = AppDomain.CurrentDomain.BaseDirectory;
}
_appSettings = LoadSettings <AppSettings>(Path.Combine(savePath, AppSettingsFileName));
_queueSettings = LoadSettings <QueueSettings>(Path.Combine(savePath, QueueSettingsFileName));
_managerSettings = LoadSettings <ManagerSettings>(Path.Combine(savePath, ManagerSettingsFileName));
_cookieList = LoadSettings <List <Cookie> >(Path.Combine(savePath, CookiesFileName));
ShellService.Settings = _appSettings;
ShellService.ShowErrorAction = ShellViewModel.ShowError;
ShellService.ShowDetailsViewAction = ShowDetailsView;
ShellService.ShowQueueViewAction = ShowQueueView;
ShellService.UpdateDetailsViewAction = UpdateDetailsView;
ShellService.SettingsUpdatedHandler += OnSettingsUpdated;
ShellService.InitializeOAuthManager();
ManagerController.QueueManager = _queueManager;
ManagerController.ManagerSettings = _managerSettings;
ManagerController.BlogManagerFinishedLoadingLibrary += OnBlogManagerFinishedLoadingLibrary;
QueueController.QueueSettings = _queueSettings;
QueueController.QueueManager = _queueManager;
DetailsController.QueueManager = _queueManager;
CrawlerController.QueueManager = _queueManager;
Task managerControllerInit = ManagerController.InitializeAsync();
QueueController.Initialize();
DetailsController.Initialize();
CrawlerController.Initialize();
_cookieService.SetUriCookie(_cookieList);
}
public static IServiceCollection RegisterQueueServices(this IServiceCollection services,
HostBuilderContext context)
{
var queueSettings = new QueueSettings();
context.Configuration.GetSection("QueueSettings").Bind(queueSettings);
services.AddMassTransit(c => { c.AddConsumer <MailChangedConsumer>(); });
services.AddSingleton(provider => Bus.Factory.CreateUsingRabbitMq(cfg =>
{
cfg.Host(queueSettings.HostName, queueSettings.VirtualHost, h =>
{
h.Username(queueSettings.UserName);
h.Password(queueSettings.Password);
});
// cfg.UseExtensionsLogging(provider.GetService<ILoggerFactory>());
}));
services.AddSingleton <IPublishEndpoint>(provider => provider.GetRequiredService <IBusControl>());
services.AddSingleton <ISendEndpointProvider>(provider => provider.GetRequiredService <IBusControl>());
services.AddSingleton <IBus>(provider => provider.GetRequiredService <IBusControl>());
return(services);
}
public ProcessorProducer(IConnectionFactory connectionFactory, QueueSettings settings) : base(connectionFactory, settings)
{
}
public Appsettings(QueueSettings queueSettings)
{
QueueSettings = queueSettings;
}
