public async Task <IActionResult> PostMessage(MessageDto messageDto)
{
var rabbitMqClient = new RabbitMqClient();
var serializedMessage = JsonConvert.SerializeObject(messageDto);
var response = rabbitMqClient.Call(serializedMessage);
rabbitMqClient.Close();
MessagePm deserializedResponse;
try
{
deserializedResponse = JsonConvert.DeserializeObject <MessagePm>(response);
}
catch (Exception e)
{
return(StatusCode(500, e.Message));
}
_messageContext.Messages.Add(deserializedResponse);
await _messageContext.SaveChangesAsync();
var messageResponseDto = new MessageResponseDto
{
Id = deserializedResponse.Id,
ExternalId = deserializedResponse.ExternalId,
Message = deserializedResponse.Message
};
return(Ok(messageResponseDto));
}
public async Task Handle(MetricQueryRequest <SingleNodeMemoryWidget> request, CancellationToken cancellationToken)
{
var ctx = request.DataContext;
var client = new RabbitMqClient(ctx.URL, ctx.Username, ctx.Password);
try
{
var nodeInfo = await client.GetNodeInfoAsync(ctx.NodesUrlPath, ctx.NodeName)
.ConfigureAwait(false);
if (!nodeInfo.IsMemoryHealthy(ctx.MaxMemoryUsagePercent, out _, out var memoryUsagePercent))
{
ctx.Value = memoryUsagePercent;
ctx.State = State.Failed;
}
else
{
ctx.Value = memoryUsagePercent;
ctx.State = State.Ok;
}
}
catch (Exception e)
{
ctx.State = State.Error;
ctx.Message = e.Message;
}
}
private static void Publish()
{
var publisher = new RabbitMqClient(new RabbitConnectionParam()
{
HostName = "localhost",
UserName = _username,
Password = _password,
QueueName = _queuename,
Vhost = "/"
});
while (true)
{
Console.WriteLine("press 'q'+enter to exit");
var read = Console.ReadLine();
if (read.ToLower() == "q")
{
break;
}
publisher.Publish(read);
}
}
public async Task <IActionResult> Post([FromBody] RedisCreateModel model)
{
await _redisDatabase.StringSetAsync($"{model.Key}", model.Value);
RabbitMqClient.Publish($"{model.Key} is successfully inserted into Redis");
return(Ok());
}
public async Task Handle(MetricQueryRequest <NodeDiskSpaceUsageWidget> request, CancellationToken cancellationToken)
{
var ctx = request.DataContext;
var client = new RabbitMqClient(ctx.URL, ctx.Username, ctx.Password);
try
{
var nodeInfo = await client.GetNodeInfoAsync(ctx.NodesUrlPath, ctx.NodeName)
.ConfigureAwait(false);
if (!nodeInfo.IsHasEnoughDiskSpace(ctx.MinFreeDiskSpacePercent, out _, out var diskSpaceUsedPercent))
{
ctx.Value = diskSpaceUsedPercent;
ctx.State = State.Failed;
}
else
{
ctx.Value = diskSpaceUsedPercent;
ctx.State = State.Ok;
}
}
catch (Exception e)
{
ctx.State = State.Error;
ctx.Message = e.Message;
}
}
public Baggage()
{
cars = new ConcurrentDictionary <string, BaggageCar>();
tokens = new ConcurrentDictionary <string, CancellationTokenSource>();
mqClient = new RabbitMqClient();
sourceDelay = new PlayDelaySource(TimeSpeedFactor);
}
public async Task Handle(HealthCheckRequest <PoliciesWidget> request, CancellationToken cancellationToken)
{
var ctx = request.DataContext;
var client = new RabbitMqClient(ctx.URL, ctx.Username, ctx.Password);
try
{
var policies = await client.GetPoliciesAsync(ctx.PoliciesUrlPath, ctx.VirtualHost).ConfigureAwait(false);
var missedPolicies = new List <string>();
foreach (var requiredPolicy in ctx.RequiredPolicies)
{
if (!policies.Any(x => x.Name == requiredPolicy))
{
missedPolicies.Add(requiredPolicy);
}
}
if (missedPolicies.Any())
{
ctx.Message = "Missed policies: " + string.Join(", ", missedPolicies);
ctx.State = State.Failed;
}
else
{
ctx.State = State.Ok;
}
}
catch (Exception e)
{
ctx.Message = e.Message;
ctx.State = State.Failed;
}
}
public async Task <RnnChiChatMessage> ProcessAsync(TextMessage message, string userContext, int replicCount)
{
using (RabbitMqClient client = new RabbitMqClient("localhost"))
{
string inputQueue = "RnnTalkService", outputQueue = "RnnTalkService";
switch (message.Language)
{
case Language.English:
inputQueue += "_input_en";
outputQueue += "_output_en";
break;
case Language.Russian:
inputQueue += "_input_ru";
outputQueue += "_output_ru";
break;
default:
throw new Exceptions.InvalidMessageException(message.Id, "Invalid Language: " + message.Language.ToString());
}
RnnChiChatMessage talkSystemRequest = new RnnChiChatMessage();
talkSystemRequest.Id = message.Id;
talkSystemRequest.TextData = message.Text;
talkSystemRequest.TalkContext = userContext;
talkSystemRequest.TalkReplicCount = replicCount;
string responeRnn;
responeRnn = await client.PostAsync(JsonConvert.SerializeObject(talkSystemRequest), inputQueue, outputQueue);
var talkSystemRespone = JsonConvert.DeserializeObject <RnnChiChatMessage>(responeRnn);
return(talkSystemRespone);
}
}
public DeicingComponent()
{
cars = new ConcurrentDictionary <string, DeicingCar>();
tokens = new ConcurrentDictionary <string, CancellationTokenSource>();
mqClient = new RabbitMqClient();
source = new PlayDelaySource(TimeSpeedFactor);
}
public RabbitMqController(
ConnectionFactory connectionFactory,
RabbitMqClient rabbitMqClient)
{
_connectionFactory = connectionFactory;
_rabbitMqClient = rabbitMqClient;
}
public TransportMotion(string Component, RabbitMqClient MqClient, PlayDelaySource source)
{
this.component = Component;
this.mqClient = MqClient;
this.source = source;
CreateQueues();
Subscribe();
}
public FollowMeComponent()
{
MqClient = new RabbitMqClient();
cars = new ConcurrentDictionary <string, FollowMeCar>();
tokens = new ConcurrentDictionary <string, CancellationTokenSource>();
source = new PlayDelaySource(timeFactor);
carTasks = new ConcurrentDictionary <string, Task>();
}
public MessagingMiddleware(RabbitMqClient rabbitMqClient, RouteMatcher routeMatcher,
IOptions <MessagingOptions> messagingOptions)
{
_rabbitMqClient = rabbitMqClient;
_routeMatcher = routeMatcher;
_endpoints = messagingOptions.Value.Endpoints.GroupBy(e => e.Method.ToUpperInvariant())
.ToDictionary(e => e.Key, e => e.ToList());
}
public void Start()
{
mqClient = new RabbitMqClient();
CreateQueues();
DeclareQueues();
mqClient.PurgeQueues(queuesFrom.Values.ToArray());
mqClient.PurgeQueues(queuesTo.Values.ToArray());
Subscribe();
}
public GroundServiceCycles(RabbitMqClient mq, ILogger logger)
{
id = count++;
firstCycle = new Cycle(logger, FirstCycleComponents);
secondCycle = new Cycle(logger, SecondCycleComponents);
this.logger = logger;
mqClient = mq;
logger?.Debug($"{GroundServiceComponent.ComponentName}: Create new service cycle with Id {id} ");
}
public void Start()
{
var mqClient = new RabbitMqClient();
mqClient.DeclareQueues(
TimetableToPassengerQueue,
ScheduleToTimetableQueue,
TimeServiceToTimetableQueue,
TimeServiceToTimetableFactorQueue
);
mqClient.PurgeQueues(
TimetableToPassengerQueue,
ScheduleToTimetableQueue,
TimeServiceToTimetableQueue,
TimeServiceToTimetableFactorQueue
);
var timetable = new ConsoleTimetable();
mqClient.SubscribeTo <CurrentPlayTime>(TimeServiceToTimetableQueue, (mes) =>
{
lock (timetable)
{
timetable.SetCurrentTime(mes.PlayTime);
timetable.Draw();
}
});
mqClient.SubscribeTo <NewTimeSpeedFactor>(TimeServiceToTimetableFactorQueue, (mes) =>
{
source.TimeFactor = mes.Factor;
});
mqClient.SubscribeTo <FlightStatusUpdate>(ScheduleToTimetableQueue, (mes) =>
{
lock (timetable)
{
// TODO if flight is departed, then remove it in N minutes
timetable.UpdateFlight(mes);
mqClient.Send(TimetableToPassengerQueue, new Timetable()
{
Flights = timetable.GetTimetable()
});
if (mes.Status == FlightStatus.Departed)
{
Task.Run(() =>
{
source.CreateToken().Sleep(TIME_TILL_REMOVING_DEPARTED_FLIGHT_MS);
lock (timetable) {
timetable.RemoveFlight(mes.FlightId);
}
});
}
}
});
}
public BusComponent()
{
mqClient = new RabbitMqClient();
cars = new ConcurrentDictionary <string, BusCar>();
commands = new ConcurrentQueue <PassengersServiceCommand>();
completionEvents = new ConcurrentDictionary <string, CountdownEvent>();
playDelaySource = new PlayDelaySource(timeFactor);
transportMotion = new TransportMotion.TransportMotion(Component.Bus, mqClient, playDelaySource);
}
public void Start(RabbitMqClient client)
{
LogManager.Configuration = new XmlLoggingConfiguration("NLog.config");
logger = LogManager.GetCurrentClassLogger();
MqClient = client;
CreateQueues();
DeclareQueues();
MqClient.PurgeQueues(queuesFrom.Values.ToArray());
Subscribe();
}
public FuelTruck()
{
mqClient = new RabbitMqClient();
cars = new ConcurrentDictionary <string, FuelTruckCar>();
commands = new ConcurrentQueue <RefuelServiceCommand>();
completionEvents = new ConcurrentDictionary <string, CountdownEvent>();
tokens = new ConcurrentDictionary <string, CancellationTokenSource>();
playDelaySource = new PlayDelaySource(timeFactor);
transportMotion = new TransportMotion.TransportMotion(Component.FuelTruck, mqClient, playDelaySource);
}
public BookingService(
BookingRepository bookingRepository,
RabbitMqClient eventBus,
ICustomerServiceApiClient customerServiceApiClient,
ICorrelationContextAccessor correlationContext)
{
_bookingRepository = bookingRepository;
_eventBus = eventBus;
_customerServiceApiClient = customerServiceApiClient;
_correlationContext = correlationContext;
}
public OrderCommandHandler(
IOrderRepository orderRepository,
ICustomerServiceApiClient customerServiceApiClient,
ICorrelationContextAccessor correlationContext,
RabbitMqClient rabbitMqClient)
{
_orderRepository = orderRepository;
_customerServiceApiClient = customerServiceApiClient;
_correlationContext = correlationContext;
_rabbitMqClient = rabbitMqClient;
}
public async Task <IActionResult> Post([FromBody] TodoListModel model)
{
if (model != null)
{
_dbContext.Add(model);
await _dbContext.SaveChangesAsync();
RabbitMqClient.Publish($"New todo item was successfully inserted into MS-SQL - > {model.Description}");
return(Ok());
}
return(BadRequest());
}
static void Main(string[] args)
{
try
{
RabbitMqClient rabbitInterceptor = new RabbitMqClient();
MessageInterceptor interceptor = new MessageInterceptor(rabbitInterceptor);
interceptor.InterceptMessage();
}
catch (Exception ex)
{
Console.WriteLine("Error occurred receiving message: " + ex.ToString());
}
}
/// <summary>
/// Publish ToggleState updated message
/// </summary>
/// <param name="toggleState"></param>
private void PublishToggleState(ToggleState toggleState)
{
if (toggleState != null && toggleState.Toggle != null && toggleState.Service != null)
{
RabbitMqClient.Publish(
new TogglerStateMessage
{
ToggleKey = toggleState.Toggle.Key,
Value = toggleState.Value,
ServiceKey = toggleState.Service.Key
},
toggleState.Service.Key
);
}
}
public async Task Handle(HealthCheckRequest <QueueStatsWidget> request, CancellationToken cancellationToken)
{
var ctx = request.DataContext;
var client = new RabbitMqClient(ctx.URL, ctx.Username, ctx.Password);
try
{
var queueStatistics = await client
.GetQueueStatisticsAsync(ctx.QueuesUrlPath, ctx.VirtualHost)
.ConfigureAwait(false);
var tooMuchMessagesQueues =
queueStatistics
.Where(x => x.Messages > ctx.MaxMessagesInQueue && new Regex(ctx.QueueFilterRegex).IsMatch(x.Name))
.Select(x => $"{x.Name} has {x.Messages} messages. ConsumersCount: {x.Consumers}");
var totalMessagesSum = queueStatistics.Sum(x => x.Messages);
var errorMessage = string.Empty;
if (totalMessagesSum >= ctx.MaxMessagesInAllQueues)
{
errorMessage = "Max messages exceeded: " + totalMessagesSum + " of " +
ctx.MaxMessagesInAllQueues + Environment.NewLine;
}
if (tooMuchMessagesQueues.Any())
{
errorMessage += string.Join(";" + Environment.NewLine, tooMuchMessagesQueues) + ";";
}
if (!string.IsNullOrEmpty(errorMessage))
{
ctx.Message = errorMessage;
ctx.State = State.Failed;
}
else
{
ctx.State = State.Ok;
ctx.Message = null;
}
}
catch (Exception e)
{
ctx.Message = e.Message;
ctx.State = State.Failed;
}
}
public async Task Handle(HealthCheckRequest <ClusterHealthCheckWidget> request,
CancellationToken cancellationToken)
{
var ctx = request.DataContext;
var client = new RabbitMqClient(ctx.URL, ctx.Username, ctx.Password);
try
{
var nodesInfo = await client.GetNodeInfosAsync(ctx.NodesUrlPath).ConfigureAwait(false);
var errors = new List <string>();
foreach (var nodeInfo in nodesInfo)
{
var error = string.Empty;
if (!nodeInfo.IsMemoryHealthy(ctx.MaxMemoryUsagePercent, out var memoryErrorMessage, out _))
{
error += memoryErrorMessage;
}
if (!nodeInfo.IsHasEnoughDiskSpace(ctx.MinFreeDiskSpacePercent, out var usedDiskSpaceError, out _))
{
error += usedDiskSpaceError;
}
if (!string.IsNullOrEmpty(error))
{
error = "For node " + nodeInfo.NodeName + " " + error;
errors.Add(error);
}
}
if (errors.Any())
{
ctx.Message = string.Join(", ", errors);
ctx.State = State.Failed;
}
else
{
ctx.State = State.Ok;
}
}
catch (Exception e)
{
ctx.State = State.Failed;
ctx.Message = e.Message;
}
}
public override async Task <TextProcessingServiceRespone> Invork(TextRequest textRequest)
{
using (RabbitMqClient client = new RabbitMqClient("localhost"))
{
var time = DateTime.Now;
string inputQueue = "RnnTalkService", outputQueue = "RnnTalkService";
TextProcessingServiceRespone respone = new TextProcessingServiceRespone
{
Id = textRequest.Id.Value,
IntentName = "none",
TextData = ""
};
if (_language == Enums.Language.English)
{
inputQueue += "_input_en";
outputQueue += "_output_en";
}
else if (_language == Enums.Language.Russian)
{
inputQueue += "_input_ru";
outputQueue += "_output_ru";
}
DbClient db = new DbClient();
var context = await db.GetContext(textRequest.Id.Value);
RnnTalkSystemRequest talkSystemRequest = new RnnTalkSystemRequest();
talkSystemRequest.Id = textRequest.Id;
talkSystemRequest.TextData = textRequest.TextData;
talkSystemRequest.TalkContext = context.TalkContext;
talkSystemRequest.TalkReplicCount = context.TalkReplicCount;
string responeRnn;
responeRnn = await client.PostAsync(JsonConvert.SerializeObject(talkSystemRequest), inputQueue, outputQueue);
var talkSystemRespone = JsonConvert.DeserializeObject <RnnTalkSystemRespone>(responeRnn);
context.TalkContext = talkSystemRespone.TalkContext;
context.TalkReplicCount = talkSystemRespone.TalkReplicCount;
await db.AddOrUpdateContext(context);
respone.TextData = talkSystemRespone.TextData;
db.Dispose();
Log.LogInformation(textRequest.Id.Value, 0, this.GetType().ToString(), $"service end work in {(DateTime.Now - time).Milliseconds} ms");
return(respone);
}
}
static void Main(string[] args)
{
var messageProvider = MessageProviderFactory.GetProvider(ProviderType.Numbers);
var rabbit = new RabbitMqClient();
rabbit.CreateQueue(QueueName);
while (true)
{
var message = messageProvider.GetMessage();
Console.WriteLine($"Publish: {message}");
rabbit.PublishMessage(message.TransformToByte(), QueueName);
Thread.Sleep(300);
}
}
static void Main(string[] args)
{
try
{
RabbitMqClient rabbitDispatcher = new RabbitMqClient();
Console.WriteLine("Enter a name: ");
string name = Console.ReadLine();
MessageDispatcher dispatcher = new MessageDispatcher(rabbitDispatcher, name);
dispatcher.DispatchMessage();
}
catch (Exception ex)
{
Console.WriteLine("Error occurred dispatching message: " + ex.ToString());
}
}
static void Main(string[] args)
{
var rabbit = new RabbitMqClient();
rabbit.SubscribeOnQueue((model, arg) =>
{
var body = arg.Body;
Console.WriteLine(body.TransformToString());
}, QueueName);
Console.WriteLine("=========");
var result = rabbit.WaitMessageFromQueue(QueueName);
Console.WriteLine(result.TransformToString());
Console.ReadKey();
}
protected override void OnStart(string[] args)
{
base.OnStart(args);
Log.Info("Version 0.5.3");
this.rabbitMqClient = new RabbitMqClient();
var basePath = Path.GetDirectoryName(Process.GetCurrentProcess().MainModule.FileName);
this.plansDir = Path.Combine(basePath, "plans");
if (!Directory.Exists(plansDir))
{
Directory.CreateDirectory(plansDir);
}
this.thread = new Thread(Loop);
this.thread.Start();
}