public void SendToQueue(IModel channel, Subscription subscription)
{
var byteMessage = ProtoSerialization.SerializeAndGetBytes(subscription);
channel.BasicPublish(exchange: brokerSubscriptionsQueueName, routingKey: "", basicProperties: null, body: byteMessage);
Logger.Log($"Sent subscriptions: {subscription}");
}
public static bool LoadData(string fileName, ProtoSerialization serializer, out STSerializedLevel out_obj)
{
string fullPath = Path.Combine(AppDocumentPath, (fileName + LevelsExtention));
bool ret = false;
out_obj = null;
if (!File.Exists(fullPath))
{
Debug.Log("Load Serialization File Not Exist At Path");
return(ret);
}
FileStream fs = null;
Debug.Log("Load Serialization File");
fs = File.OpenRead(fullPath);
out_obj = serializer.Deserialize(fs, null, typeof(STSerializedLevel)) as STSerializedLevel;
ret = true;
Debug.Log("Load Serialization Complete");
if (fs != null)
{
fs.Close();
}
return(ret);
}
private static void SendToQueue(IModel channel, IBasicProperties properties, Publication publication)
{
var bytes = ProtoSerialization.SerializeAndGetBytes(publication);
channel.BasicPublish(exchange: "", routingKey: exchangeAgent, basicProperties: properties, body: bytes);
Logger.Log($" [*] Sent publication: {publication} |");
}
public void ForwardSubscription(Subscription subscription)
{
if (subscription.ForwardNumber == (Constants.NumberOfBrokers - 1))
{
return;
}
string forwardId = GetNextBrokerId(subscription);
var s = new Subscription
{
Id = subscription.Id,
SenderId = $"B{brokerId}",
Filter = subscription.Filter,
ForwardNumber = subscription.ForwardNumber + 1
};
var brokerSubscriptionsQueueName = $"Subscriptions_{forwardId}";
using (var connection = factory.CreateConnection())
{
using (var channel = connection.CreateModel())
{
channel.ExchangeDeclare(exchange: brokerSubscriptionsQueueName, type: "direct");
var byteMessage = ProtoSerialization.SerializeAndGetBytes(s);
channel.BasicPublish(exchange: brokerSubscriptionsQueueName, routingKey: "", basicProperties: null, body: byteMessage);
Logger.Log($" [*] Forwarded subscription: {s}");
}
}
}
private static void SendForwardsPublication(Publication publication, string receiverId)
{
var body = ProtoSerialization.SerializeAndGetBytes(publication);
ChanelPublicationsForward.BasicPublish(exchange: forwardPublicationsExchange,
routingKey: receiverId,
basicProperties: null,
body: body);
Logger.Log($" [x] Sent forward publication to {receiverId} : {publication}");
}
static public STLevel Instance()
{
if (_instance == null)
{
GameObject level = GameObject.Find("Level");
if (level == null)
{
Debug.LogError("Error get Level");
return(null);
}
_instance = level.GetComponent <STLevel>();
_instance.RootNode = GameObject.Instantiate(_instance.RootNode) as STRootNode;
// GameObject obj = GameObject.Find ("RootNode");
// _instance.RootNode = obj.GetComponent <STRootNode> ();
if (_instance.RootNode == null)
{
Debug.LogError("Error getting root node");
return(null);
}
// public GameObject Node;
// public GameObject Leaf;
// public GameObject ActiveNode;
// _instance.RootNode.mVisual.ActiveNode.renderer.enabled = false;
// _instance.RootNode.mVisual.Leaf.renderer.enabled = false;
// _instance.RootNode.mVisual.Node.renderer.enabled = false;
_instance.NodesNet = GameObject.Instantiate(_instance.NodesNet) as STNodesNet;
if (_instance.NodesNet == null)
{
Debug.LogError("Error getting nodes net");
return(null);
}
_instance.Control = GameObject.Find("Background").GetComponent <STControl>();
_instance.SkinsMngr = GameObject.Instantiate(_instance.SkinsMngr) as STSkinsManager;
if (_instance.SkinsMngr == null)
{
Debug.LogError("Error getting skins manager");
return(null);
}
sLevelSerializer = new ProtoSerialization();
}
return(_instance);
}
private static void SendToConsumerQueue(IModel channel, Publication publication, string receiverId)
{
Logger.Log($" [*] Send to consumer", true);
Logger.Log($" [*] Send to consumer {publication}");
var bytes = ProtoSerialization.SerializeAndGetBytes(publication);
channel.QueueDeclare(queue: receiverId, durable: true, exclusive: false, autoDelete: false, arguments: null);
var properties = channel.CreateBasicProperties();
properties.Persistent = true;
channel.BasicPublish(exchange: "", routingKey: receiverId, basicProperties: properties, body: bytes);
}
private static void ConsumePublications(object model, BasicDeliverEventArgs eventArguments)
{
var body = eventArguments.Body;
var publication = ProtoSerialization.Deserialize <Publication>(body);
var latency = GetLatency(publication);
Latencies.Add(latency);
Logger.Log($" [*] Received publication {Latencies.Count}", true);
// UpdateAverageLatency(latency);
// var routingKey = eventArguments.RoutingKey;
Logger.Log($" [*] Received publication {publication}\n Latency:{latency}");
// ShowAverageLatency();
}
private static void ConsumeForwardedPublications(object sender, BasicDeliverEventArgs e)
{
var publication = ProtoSerialization.Deserialize <Publication>(e.Body);
Logger.Log($" [x] Received forwarded publication on routing key {e.RoutingKey}", true);
if (SubscriptionsMap[publication.SubscriptionMatchId].SenderId.StartsWith('B'))
{
SendForwardsPublication(publication, SubscriptionsMap[publication.SubscriptionMatchId].SenderId);
}
else
{
SendToConsumerQueue(ChanelPublicationsConsumer, publication, SubscriptionsMap[publication.SubscriptionMatchId].SenderId);
}
}
public static bool SaveData(STSerializedLevel obj, ProtoSerialization serializer, string fileName, bool shouldRewrite)
{
string fullPath = Path.Combine(AppDocumentPath, (fileName + LevelsExtention));
//Debug.Log("Save Serialized Data to : " + fullPath);
bool ret = false;
if (File.Exists(fullPath))
{
Debug.Log("Save Serialized Data Delete Old File");
if (shouldRewrite == false)
{
return(false);
}
File.Delete(fullPath);
}
FileStream fs = new FileStream(fullPath, FileMode.Create);
if (fs != null)
{
//ProtoSerialization pSerializer = serializer as ProtoSerialization;
serializer.Serialize(fs, obj);
// if (pSerializer.CanSerialize (typeof ( STSerializedLevel)))
// {
// Debug.Log ("CAN SER");
// }
// else
// Debug.Log ("CAN NOT SER");
//
ret = true;
Debug.Log("Save Serialization Complete");
if (fs != null)
{
fs.Close();
}
}
else
{
Debug.Log("FS ERROR");
}
return(ret);
}
private void DealWithSubscriptions(object model, BasicDeliverEventArgs ea)
{
var subscription = ProtoSerialization.Deserialize <Subscription>(ea.Body);
Logger.Log($" [*] Received subscription {subscription}");
Logger.Log($"S {++subscriptionNumber}", true);
if (Program.RecieverSubscriptionsMap.ContainsKey(subscription.SenderId))
{
Program.RecieverSubscriptionsMap[subscription.SenderId].Add(subscription);
}
else
{
Program.RecieverSubscriptionsMap[subscription.SenderId] = new List <Subscription>()
{
subscription
};
}
if (!Program.SubscriptionsMap.ContainsKey(subscription.Id))
{
Program.SubscriptionsMap.Add(subscription.Id, subscription);
}
ForwardSubscription(subscription);
}
private static void Broker(IModel channelReceiver, IModel channelSender)
{
var consumer = new EventingBasicConsumer(channelReceiver);
consumer.Received += (model, eventArguments) =>
{
var body = eventArguments.Body;
var publication = ProtoSerialization.Deserialize <Publication>(body);
Logger.Log($" [x] Received publication {publication} ");
var matchedSubscriptions = new List <Subscription>();
try
{
matchedSubscriptions = FilterMessageBasedOnSubscriptions(publication);
}
catch (Exception e)
{
Logger.Log(e.Message);
}
foreach (var subscriptions in matchedSubscriptions)
{
publication.SubscriptionMatchId = subscriptions.Id;
if (subscriptions.SenderId.StartsWith('C'))
{
SendToConsumerQueue(channelSender, publication, subscriptions.SenderId);
}
if (subscriptions.SenderId.StartsWith('B'))
{
SendForwardsPublication(publication, subscriptions.SenderId);
}
}
};
channelReceiver.BasicConsume(queue: receiverQueueName,
autoAck: true,
consumer: consumer);
}
