// Summary:
// Sets the new instance's properties from the arguments passed in.
public BasicGetResult(RabbitMQ.Client.BasicGetResult result)
{
BasicProperties = result.BasicProperties;
Body = result.Body;
DeliveryTag = result.DeliveryTag;
Exchange = result.Exchange;
MessageCount = result.MessageCount;
Redelivered = result.Redelivered;
RoutingKey = result.RoutingKey;
}
private void UpdateThread(object state)
{
while (true)
{
RabbitMQ.Messages lst = RabbitMQ.Get(QueueName, ChannelName);
if (RabbitMQ.IsException)
{
break;
}
if (lst.Count > 0)
{
Dispatcher.BeginInvoke(DispatcherPriority.Render,
(Action)(() =>
{
DeserializeJSONtoDataGrid(lst);
}));
}
else
{
Dispatcher.BeginInvoke(DispatcherPriority.Render,
(Action)(() =>
{
LblState.Content = "Loaded";
}));
}
Thread.Sleep(1000);
}
Dispatcher.BeginInvoke(DispatcherPriority.Render,
(Action)(() =>
{
LblState.Content = "Exited";
}));
}
public ActionResult Save(RabbitMQ model, int?id)
{
DBEntities e = COREobject.i.Context;
if (ModelState.IsValid)
{
// Záznam ji. existuje - pouze upravujeme
if (!model.Id.Equals(null))
{
RabbitMQ row = e.RabbitMQs.Single(m => m.Id == model.Id);
e.Entry(row).CurrentValues.SetValues(model);
}
else
{
e.RabbitMQs.Add(model);
e.SaveChanges();
}
e.SaveChanges();
if (model.Type == ChannelType.RECEIVE)
{
RabbitMQListenerService.AddListener(model);
}
return(RedirectToRoute("Nexus", new { @action = "Index" }));
}
else
{
return(View("~/Views/Nexus/RabbitMQ/Form.cshtml", model));
}
}
public override void Init()
{
amqp = new RabbitMQ();
amqp.acceptAnswer = acceptAnswer;
amqp.Open();
start();
}
internal static void Publish(string exchangeName, string routingKey, With.Message.ISerializer messageSerializer, RabbitMQ.Client.IModel model, With.Message.IMessage message)
{
string content = messageSerializer.Serialize(message);
byte[] body = Encoding.Encode(content);
IBasicProperties properties = model.CreateBasicProperties();
model.BasicPublish(exchangeName, routingKey, properties, body);
}
protected override void Implement(RabbitMQ.Client.IModel channel, RabbitMQ.Client.Events.BasicDeliverEventArgs ea)
{
var body = ea.Body;
var message = Encoding.UTF8.GetString(body);
Console.WriteLine(" worker1 Received {0}", message);
System.Threading.Thread.Sleep(10000);
channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false);
}
public override byte[] HandleCall(bool isRedelivered, RabbitMQ.Client.IBasicProperties requestProperties, byte[] body, out RabbitMQ.Client.IBasicProperties replyProperties)
{
string productName = ASCIIEncoding.ASCII.GetString(body);
Console.WriteLine("Received order for producted named '{0}'", productName);
string orderId = Guid.NewGuid().ToString();
replyProperties = requestProperties;
byte[] respBody = ASCIIEncoding.ASCII.GetBytes(orderId);
return respBody;
}
public RabbitMQQueueView(RabbitMQ rabbitMQ, KeyValuePair <string, Type> cmd)
{
InitializeComponent();
RabbitMQ = rabbitMQ;
RabbitMQ.CreateNewChannel(ChannelName);
QueueName = cmd.Key;
ClassType = cmd.Value;
LblQueueName.Content = QueueName;
ThreadPool.QueueUserWorkItem(UpdateThread);
}
public ActionResult Delete(int?id)
{
DBEntities e = COREobject.i.Context;
RabbitMQ row = e.RabbitMQs.Single(l => l.Id == id);
if (row == null)
{
throw new Exception("Došlo k neoèekávané chybì");
}
e.RabbitMQs.Remove(row);
e.SaveChanges();
return(RedirectToRoute("Nexus", new { @action = "Index" }));
}
private void Consumer_ConnectionLost(RabbitMQ.Client.IConnection connection,
RabbitMQ.Client.ShutdownEventArgs reason)
{
Consumer.ConnectionLost -= Consumer_ConnectionLost;
Log.Warning("Connection lost to RabbitMQ Server due to {0}", reason.Cause);
try
{
Consumer.StartConsuming();
}
catch (Exception ex)
{
Log.Warning(ex, "Shutting down old connection to allow new connection to replace it");
}
InitializeQueueConnection();
StartConsuming();
}
public ActionResult Edit(int?id)
{
DBEntities e = COREobject.i.Context;
RabbitMQ model = e.RabbitMQs.Single(l => l.Id == id);
List <SelectListItem> appList = new List <SelectListItem>();
foreach (Application a in e.Applications.OrderBy(a => a.Name))
{
appList.Add(new SelectListItem()
{
Value = a.Id.ToString(), Text = a.Name, Selected = model.ApplicationId == a.Id
});
}
ViewData["ApplicationList"] = appList;
return(View("~/Views/Nexus/RabbitMQ/Form.cshtml", model));
}
public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer)
{
writer.WriteShort(m_replyCode);
writer.WriteShortstr(m_replyText);
writer.WriteShortstr(m_exchange);
writer.WriteShortstr(m_routingKey);
}
public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader)
{
m_replyCode = reader.ReadShort();
m_replyText = reader.ReadShortstr();
m_exchange = reader.ReadShortstr();
m_routingKey = reader.ReadShortstr();
}
public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader)
{
m_ticket = reader.ReadShort();
m_queue = reader.ReadShortstr();
m_noAck = reader.ReadBit();
}
public void Post([FromBody] dynamic value)
{
IEnumerable <DateSenzori> IdateDePrelucrat;
IEnumerable <IntervalValide> IintervalDeDate;
SqlConnection DBConnection = null;
SqlCommand insertCommand = null;
SqlCommand deleteCommand = null;
string dataString = Convert.ToString(value);
try
{
// IdateDePrelucrat = JsonConvert.DeserializeObject<IEnumerable<DateSenzori>>(value);
IintervalDeDate = JsonConvert.DeserializeObject <IEnumerable <IntervalValide> >(dataString);
if (IintervalDeDate == null || (IintervalDeDate.First().Temperatura_Max == 0 && IintervalDeDate.First().Temperatura_Min == 0 &&
IintervalDeDate.First().Umididate_Max == 0 && IintervalDeDate.First().Umididate_Min == 0))
{
try
{
IdateDePrelucrat = JsonConvert.DeserializeObject <IEnumerable <DateSenzori> >(dataString);
DBConnection = new SqlConnection(connection);
DBConnection.Open();
foreach (var item in IdateDePrelucrat)
{
try
{
string insertCmd = string.Format
(
"INSERT INTO DataToBeProcessed VALUES({0},{1},{2},{3})",
item.Zona, "'" + item.Data + "'", item.Temperatura, item.Umiditate
);
insertCommand = new SqlCommand(insertCmd, DBConnection);
insertCommand.ExecuteNonQuery();
deleteCommand.Dispose();
}
catch (Exception e)
{
e.Message.ToString();
}
}
}
catch (Exception e)
{
e.Message.ToString();
}
string mesaj = "ti-am_trimis";
RabbitMQ rabbitmq = new RabbitMQ();
// rabbitmq.Publish(mesaj);
}
else
{
DBConnection = new SqlConnection(connection);
DBConnection.Open();
string deleteCmd = "DELETE FROM DataRange";
string insertCmd = string.Format
(
"INSERT INTO DataRange VALUES({0},{1},{2},{3})",
IintervalDeDate.First().Temperatura_Min, IintervalDeDate.First().Temperatura_Max, IintervalDeDate.First().Umididate_Min, IintervalDeDate.First().Umididate_Max
);
insertCommand = new SqlCommand(insertCmd, DBConnection);
deleteCommand = new SqlCommand(deleteCmd, DBConnection);
deleteCommand.ExecuteNonQuery();
insertCommand.ExecuteNonQuery();
insertCommand.Dispose();
deleteCommand.Dispose();
}
}
catch (Exception e)
{
e.Message.ToString();
}
finally
{
if (DBConnection != null)
{
DBConnection.Dispose();
}
}
}
public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader)
{
m_ticket = reader.ReadShort();
m_queue = reader.ReadShortstr();
m_exchange = reader.ReadShortstr();
m_routingKey = reader.ReadShortstr();
m_arguments = reader.ReadTable();
}
public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer)
{
writer.WriteTable(m_metaData);
}
public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer)
{
}
protected internal virtual IModel CreateInboundModel(RabbitMQ.Client.IConnection connection,
UInt32 prefetchSize,
UInt16 prefetchCount)
{
var model = connection.CreateModel();
model.BasicQos(prefetchSize, prefetchCount, false);
return model;
}
protected internal override IModel CreateInboundModel(RabbitMQ.Client.IConnection connection,
UInt32 prefetchSize,
UInt16 prefetchCount)
{
return _model;
}
public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader)
{
m_consumerTag = reader.ReadShortstr();
}
static void Main(string[] args)
{
mQ = new RabbitMQ();
mQ.ConsumeEvents(OnQueueEventRecevied);
}
public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer)
{
writer.WriteShort(m_ticket);
writer.WriteShortstr(m_queue);
writer.WriteShortstr(m_consumerTag);
writer.WriteBit(m_noLocal);
writer.WriteBit(m_exclusive);
writer.WriteBit(m_nowait);
writer.WriteTable(m_filter);
}
public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader)
{
m_ticket = reader.ReadShort();
m_queue = reader.ReadShortstr();
m_consumerTag = reader.ReadShortstr();
m_noLocal = reader.ReadBit();
m_exclusive = reader.ReadBit();
m_nowait = reader.ReadBit();
m_filter = reader.ReadTable();
}
public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer)
{
writer.WriteShort(m_ticket);
writer.WriteShortstr(m_queue);
writer.WriteShortstr(m_exchange);
writer.WriteShortstr(m_routingKey);
writer.WriteTable(m_arguments);
}
public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer)
{
writer.WriteShort(m_ticket);
writer.WriteShortstr(m_queue);
writer.WriteBit(m_noAck);
}
public static Task WithEventHandlerAsync <TEvent>(this IBusClient bus,
IEventHandler <TEvent> handler) where TEvent : IEvent
=> bus.SubscribeAsync <TEvent>(msg => handler.HandleAsync(msg),
ctx => ctx.UseConsumerConfiguration(cfg =>
cfg.FromDeclaredQueue(RabbitMQ => RabbitMQ.WithName(GetQueueName <TEvent>()))));
public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader)
{
m_metaData = reader.ReadTable();
}
public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer)
{
writer.WriteShort(m_ticket);
writer.WriteShortstr(m_exchange);
writer.WriteShortstr(m_routingKey);
writer.WriteBit(m_mandatory);
writer.WriteBit(m_immediate);
}
public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader)
{
}
public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader)
{
m_prefetchSize = reader.ReadLong();
m_prefetchCount = reader.ReadShort();
m_consumeRate = reader.ReadLong();
m_global = reader.ReadBit();
}
static void Main(string[] args)
{
rabbitMQ = new RabbitMQ();
//rabbitMQ.channel = rabbitMQ.GetChannel();
rabbitMQ.StartExcusiveConsuming(Guid.NewGuid().ToString("N"));
}
public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer)
{
writer.WriteLong(m_prefetchSize);
writer.WriteShort(m_prefetchCount);
writer.WriteLong(m_consumeRate);
writer.WriteBit(m_global);
}
public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer)
{
writer.WriteShortstr(m_consumerTag);
}
public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer)
{
writer.WriteLong(m_messageCount);
}
private void DSDPSNode_ConnectionShutdown(object sender, RabbitMQ.Client.ShutdownEventArgs e)
{
Console.WriteLine("[Error] Disconnected from rabbitMQ server.");
//if(updateManager.updateBlockingMRE.WaitOne())
Environment.Exit(8);
}
public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader)
{
m_consumerTag = reader.ReadShortstr();
m_deliveryTag = reader.ReadLonglong();
m_exchange = reader.ReadShortstr();
m_queue = reader.ReadShortstr();
}
private IConnection CreateConnection(RabbitMQ.Client.IConnection connection,
IModel outboundModel)
{
var builder = new ConsumedMessageBuilder(_configuration.SerializationConfiguration,
_configuration.MessageTypeResolver);
var outboundChannel = _configuration.OutboundChannelBuilder(outboundModel,
_configuration);
var consumers = _promises.Select(_ =>
{
var model = CreateInboundModel(connection,
_configuration.PrefetchSize,
_configuration.PrefetchCount);
var consumer = _(builder).BuildConsumer(new InboundChannel(model),
outboundChannel);
return new { Model = model, Consumer = consumer };
})
.ToList();
foreach (var consumer in consumers)
consumer.Consumer.Declare(consumer.Model);
return new Connection(connection,
consumers.Select(_ => _.Consumer),
outboundChannel,
_configuration);
}
public override void WriteArgumentsTo(RabbitMQ.Client.Impl.MethodArgumentWriter writer)
{
writer.WriteShortstr(m_consumerTag);
writer.WriteLonglong(m_deliveryTag);
writer.WriteShortstr(m_exchange);
writer.WriteShortstr(m_queue);
}
public override void ReadArgumentsFrom(RabbitMQ.Client.Impl.MethodArgumentReader reader)
{
m_ticket = reader.ReadShort();
m_exchange = reader.ReadShortstr();
m_routingKey = reader.ReadShortstr();
m_mandatory = reader.ReadBit();
m_immediate = reader.ReadBit();
}
public async Task <IActionResult> Test(Storeage message)
{
Storeages.Add(message);
RabbitMQ.PublicMessage <IMessage>(message.Message);
return(Ok());
}