public QpidResourceHolder(IClientFactory connectionFactory, IClient connection, IClientSession channel)
{
this.clientFactory = connectionFactory;
AddConnection(connection);
AddChannel(channel);
this.frozen = true;
}
public bool rcvMeta(IClientSession session, IMutableMessage message)
{
Dictionary<String, Object> ext = (Dictionary<String, Object>)message.getExt(false);
if (ext != null)
{
Dictionary<String, Object> sync = (Dictionary<String, Object>)ext["timesync"];
if (sync != null)
{
long now = (System.DateTime.Now.Ticks - 621355968000000000) / 10000;
long tc = ObjectConverter.ToInt64(sync["tc"], 0);
long ts = ObjectConverter.ToInt64(sync["ts"], 0);
int p = ObjectConverter.ToInt32(sync["p"], 0);
// final int a=((Number)sync.get("a")).intValue();
int l2 = (int)((now - tc - p) / 2);
int o2 = (int)(ts - tc - l2);
_lag = _lag == 0 ? l2 : (_lag + l2) / 2;
_offset = _offset == 0 ? o2 : (_offset + o2) / 2;
}
}
return true;
}
internal void SignOut(IClientSession session)
{
if (_sessions.Remove(session))
{
if (_sessions.Count == 0)
this.Status = ChatUserStatus.Offline;
BroadcastStatus();
}
}
public bool sendMeta(IClientSession session, IMutableMessage message)
{
Dictionary<String, Object> ext = (Dictionary<String, Object>)message.getExt(true);
long now = (System.DateTime.Now.Ticks - 621355968000000000) / 10000;
// Changed JSON.Literal to String
String timesync = "{\"tc\":" + now + ",\"l\":" + _lag + ",\"o\":" + _offset + "}";
ext["timesync"] = timesync;
return true;
}
private static void publishMessages(IClientSession session, string routing_key)
{
IMessage message = new Message();
// Asynchronous transfer sends messages as quickly as
// possible without waiting for confirmation.
for (int i = 0; i < 10; i++)
{
message.ClearData();
message.AppendData(Encoding.UTF8.GetBytes("Message " + i));
session.MessageTransfer("amq.topic", routing_key, message);
}
}
public bool sendMeta(IClientSession session, IMutableMessage message)
{
if (Channel_Fields.META_HANDSHAKE.Equals(message.Channel))
{
message.getExt(true)[EXT_FIELD] = true;
_ackId = -1;
}
else if (_serverSupportsAcks && Channel_Fields.META_CONNECT.Equals(message.Channel))
{
message.getExt(true)[EXT_FIELD] = _ackId;
}
return true;
}
public bool SendMeta(IClientSession session, IMutableMessage message)
{
switch (message.Channel)
{
case ChannelFields.MetaHandshake:
message.GetExt(true)[ExtField] = true;
break;
case ChannelFields.MetaSubscribe:
message.GetExt(true)[ExtField] = new Dictionary <string, long>(_channelToReplayId);
break;
}
return(true);
}
public static void CloseChannel(IClientSession channel)
{
if (channel != null)
{
try
{
channel.Close();
}
//TODO should this really be trace level?
catch (Exception ex)
{
logger.Debug("Unexpected exception on closing RabbitMQ Channel", ex);
}
}
}
public static void Send(this IClientSession session, IPacket packet)
{
if (session == null)
{
throw new ArgumentNullException(nameof(session));
}
if (packet == null)
{
throw new ArgumentNullException(nameof(packet));
}
var byteAryForMsg = packet.Data;
session.Send(byteAryForMsg, 0, byteAryForMsg.Length);
}
public static void CloseChannel(IClientSession channel)
{
if (channel != null)
{
try
{
channel.Close();
}
//TODO should this really be trace level?
catch (Exception ex)
{
logger.Debug("Unexpected exception on closing RabbitMQ Channel", ex);
}
}
}
// Clients
public bool Login(IClientSession clientSession)
{
bool result;
try
{
Store(clientSession);
result = true;
}
catch (Exception)
{
result = false;
//TODO: log exception
}
return(result);
}
public void BeginConnect(EndPoint serverEndPoint)
{
if (PipeLineProcessor == null)
throw new Exception("This client has not been initialized.");
m_Session = new AsyncTcpSession(serverEndPoint, 4096);
m_Session.Connected += new EventHandler(m_Session_Connected);
m_Session.Error += new EventHandler<ErrorEventArgs>(m_Session_Error);
m_Session.Closed += new EventHandler(m_Session_Closed);
m_Session.DataReceived += new EventHandler<DataEventArgs>(m_Session_DataReceived);
if (ReceiveBufferSize > 0)
m_Session.ReceiveBufferSize = ReceiveBufferSize;
m_Session.Connect();
}
// We need to add auth-headers etc...
public HttpAppClient(IClientSession session, ILogger logger)
{
_session = session;
_logger = logger;
_client = new HttpClient();
_client.DefaultRequestHeaders.Add("session-id", session.Id.ToString());
buffer = new ActionBlock <IAggregateOperation> [16];
for (int i = 0; i < buffer.Length; i++)
{
buffer[i] = new ActionBlock <IAggregateOperation>(x => x.Run(), new ExecutionDataflowBlockOptions()
{
EnsureOrdered = true
});
}
}
public static void FromBytes(this IClientSession clientSession, byte[] buffer)
{
if (buffer == null)
{
return;
}
using (var inputStream = new MemoryStream(buffer))
// using (var zippedStream = new GZipStream(inputStream, CompressionMode.Decompress))
using (var streamReader = new StreamReader(inputStream))
{
var settings = streamReader.ReadToEnd();
JsonConvert.PopulateObject(settings, clientSession);
}
}
public static byte[] ToBytes(this IClientSession clientSession)
{
using (var outputStream = new MemoryStream())
// using (var zippedStream = new GZipStream(output, CompressionMode.Compress))
using (var streamWriter = new StreamWriter(outputStream))
using (var jWriter = new JsonTextWriter(streamWriter))
{
var serializer = new JsonSerializer();
serializer.Serialize(jWriter, clientSession);
jWriter.Flush();
streamWriter.Flush();
return(outputStream.ToArray());
}
}
private object InvokeOperation(IClientSession session, string operation, object parameter, Func <OperationWrapper, OperationContext, Object> resultFunc)
{
Assert.NullArgument(session, "session");
Assert.EmptyString(operation, "operation");
Assert.NullArgument(resultFunc, "resultFunc");
OperationWrapper wrapper = null;
if (_operations.TryGetValue(operation, out wrapper))
{
var context = new OperationContext(session, wrapper, parameter);
return(resultFunc.Invoke(wrapper, context));
}
else
{
throw new PipelineException("Operation not found: ".Templ(operation));
}
}
private void SetSessionByUser(string login, IClientSession session, bool setting)
{
List <IClientSession> buffer = null;
if (!_sessionsByUser.TryGetValue(login, out buffer))
{
buffer = _sessionsByUser[login] = new List <IClientSession>();
}
if (setting)
{
buffer.Add(session);
}
else
{
buffer.Remove(session);
}
}
public void SubscribeWithImage(List <string> topic, string svrId, string signalId)
{
if (topic == null || topic.Count == 0)
{
log.Warn("Topic is null,so can't subscribeWithImage!");
return;
}
foreach (string t in topic)
{
topics.Add(new BaseDestination(t));
}
if (_conn != null && _conn.Connected)
{
_session = _conn.createSession();
_session.subscribe(topics, svrId, signalId, this);
}
}
protected void TryToConnect()
{
reqsOutstanding = 1;
Agent newAgent = new Agent(this, 0, "BrokerAgent");
Agents.Add(newAgent.AgentKey(), newAgent);
client = new Client();
client.Connect(url.Hostname, url.Port, null, url.AuthName, url.AuthPassword);
clientSession = client.CreateSession(timeout);
//clientSession.SetAutoSync(false) ;
string name = System.Text.Encoding.UTF8.GetString(clientSession.GetName());
replyName = "reply-" + name;
topicName = "topic-" + name;
clientSession.SetAutoSync(true);
Option[] options = new Option[] { Option.EXCLUSIVE, Option.AUTO_DELETE };
// This queue is used for responses to messages which are sent.
clientSession.QueueDeclare(replyName, options);
clientSession.ExchangeBind(replyName, "amq.direct", replyName);
clientSession.AttachMessageListener(this, "rdest");
clientSession.MessageSubscribe(replyName, "rdest", MessageAcceptMode.NONE, MessageAcquireMode.PRE_ACQUIRED, null, 0, null);
clientSession.MessageSetFlowMode("rdest", MessageFlowMode.WINDOW);
clientSession.MessageFlow("rdest", MessageCreditUnit.BYTE, ClientSession.MESSAGE_FLOW_MAX_BYTES);
clientSession.MessageFlow("rdest", MessageCreditUnit.MESSAGE, ClientSession.MESSAGE_FLOW_MAX_BYTES);
// This queue is used for unsolicited messages sent to this class.
clientSession.QueueDeclare(topicName, options);
clientSession.AttachMessageListener(this, "tdest");
clientSession.MessageSubscribe(topicName, "tdest", MessageAcceptMode.NONE, MessageAcquireMode.PRE_ACQUIRED, null, 0, null);
clientSession.MessageSetFlowMode("tdest", MessageFlowMode.WINDOW);
clientSession.MessageFlow("tdest", MessageCreditUnit.BYTE, ClientSession.MESSAGE_FLOW_MAX_BYTES);
clientSession.MessageFlow("tdest", MessageCreditUnit.MESSAGE, ClientSession.MESSAGE_FLOW_MAX_BYTES);
outSession = client.CreateSession(timeout);
outSession.ExchangeBind(replyName, "amq.direct", replyName);
connected = true;
consoleSession.HandleBrokerConnect(this);
IEncoder encoder = CreateEncoder();
this.SetHeader(encoder, 'B', 0);
this.Send(encoder);
}
public void SendMessage(IClientSession session, string messageId, object data)
{
lock (__lockObject)
{
List <IPipelineMessageItem> buffer = null;
if (!_messages.TryGetValue(session.SessionId, out buffer))
{
buffer = new List <IPipelineMessageItem>();
_messages[session.SessionId] = buffer;
}
buffer.Insert(0, new MessageBufferItem(messageId, data));
if (buffer.Count > 511)
{
buffer.RemoveAt(buffer.Count - 1);
}
}
}
static void Main(string[] args)
{
string host = ConfigurationManager.AppSettings["Host"];
int port = int.Parse(ConfigurationManager.AppSettings["Port"]);
string virtualhost = ConfigurationManager.AppSettings["VirtualHost"];
string username = ConfigurationManager.AppSettings["Username"];
string password = ConfigurationManager.AppSettings["Password"];
Client connection = new Client();
try
{
connection.Connect(host, port, virtualhost, username, password);
IClientSession session = connection.CreateSession(50000);
//--------- Main body of program --------------------------------------------
// Unlike topic exchanges and direct exchanges, a fanout
// exchange need not set a routing key.
IMessage message = new Message();
// Asynchronous transfer sends messages as quickly as
// possible without waiting for confirmation.
for (int i = 0; i < 10; i++)
{
message.ClearData();
message.AppendData(Encoding.UTF8.GetBytes("Message " + i));
session.MessageTransfer("amq.fanout", message);
}
// And send a syncrhonous final message to indicate termination.
message.ClearData();
message.AppendData(Encoding.UTF8.GetBytes("That's all, folks!"));
session.MessageTransfer("amq.fanout", message);
session.Sync();
//-----------------------------------------------------------------------------
connection.Close();
}
catch (Exception e)
{
Console.WriteLine("Error: \n" + e.StackTrace);
}
}
public Task<bool> ConnectAsync(EndPoint serverEndPoint)
{
if (PipeLineProcessor == null)
throw new Exception("This client has not been initialized.");
m_ConnectTaskSource = new TaskCompletionSource<bool>();
m_Session = new AsyncTcpSession(serverEndPoint, 4096);
m_Session.Connected += new EventHandler(m_Session_Connected);
m_Session.Error += new EventHandler<ErrorEventArgs>(m_Session_Error);
m_Session.Closed +=new EventHandler(m_Session_Closed);
m_Session.DataReceived += new EventHandler<DataEventArgs>(m_Session_DataReceived);
if (ReceiveBufferSize > 0)
m_Session.ReceiveBufferSize = ReceiveBufferSize;
m_Session.Connect();
return m_ConnectTaskSource.Task;
}
public Task<bool> ConnectAsync(EndPoint serverEndPoint)
{
if (PipeLineProcessor == null)
throw new Exception("This client has not been initialized.");
m_ConnectTaskSource = new TaskCompletionSource<bool>();
m_Session = new AsyncTcpSession(serverEndPoint, 4096);
m_Session.Connected += new EventHandler(m_Session_Connected);
m_Session.Error += new EventHandler<ErrorEventArgs>(m_Session_Error);
m_Session.Closed +=new EventHandler(m_Session_Closed);
m_Session.DataReceived += new EventHandler<DataEventArgs>(m_Session_DataReceived);
if (ReceiveBufferSize > 0)
m_Session.ReceiveBufferSize = ReceiveBufferSize;
m_Session.Connect();
return m_ConnectTaskSource.Task;
}
public bool ReceiveMeta(IClientSession session, IMutableMessage message)
{
if (ChannelFields.META_HANDSHAKE.Equals(message.Channel))
{
var ext = (Dictionary <string, object>)message.GetExt(false);
_serverSupportsAcks = ext != null && true.Equals(ext[EXT_FIELD]);
}
else if (_serverSupportsAcks && true.Equals(message[MessageFields.SUCCESSFUL_FIELD]) && ChannelFields.META_CONNECT.Equals(message.Channel))
{
var ext = (Dictionary <string, object>)message.GetExt(false);
if (ext != null)
{
ext.TryGetValue(EXT_FIELD, out var ack);
_ackId = ObjectConverter.ToInt32(ack, _ackId);
}
}
return(true);
}
public void Login()
{
using (var connector = new Connector())
{
IClientSession session = connector.Login("User1", "Machine1");
Assert.IsNotNull(session);
Assert.IsTrue(session.IsLoggedIn);
Assert.AreEqual("User1", session.Name);
Assert.AreEqual("Machine1", session.Endpoint);
IClient client = connector.GetClient("User1");
Assert.IsNotNull(client);
Assert.AreEqual("User1", client.Name);
Assert.AreEqual("Machine1", client.LastLoginEndpoint);
session.Dispose();
Assert.IsFalse(session.IsLoggedIn);
}
}
static void Main(string[] args)
{
string host = ConfigurationManager.AppSettings["Host"];
int port = int.Parse(ConfigurationManager.AppSettings["Port"]);
string virtualhost = ConfigurationManager.AppSettings["VirtualHost"];
string username = ConfigurationManager.AppSettings["Username"];
string password = ConfigurationManager.AppSettings["Password"];
Client connection = new Client();
try
{
connection.Connect(host, port, virtualhost, username, password);
IClientSession session = connection.CreateSession(50000);
//--------- Main body of program --------------------------------------------
// Create a request queue for clients to use when making
// requests.
const string request_queue = "request";
// Use the name of the request queue as the routing key
session.QueueDeclare(request_queue);
session.ExchangeBind(request_queue, "amq.direct", request_queue);
lock (session)
{
// Create a listener and subscribe it to the request_queue
IMessageListener listener = new MessageListener(session);
session.AttachMessageListener(listener, request_queue);
session.MessageSubscribe(request_queue);
// Receive messages until all messages are received
Console.WriteLine("Waiting for requests");
Monitor.Wait(session);
}
//---------------------------------------------------------------------------
connection.Close();
}
catch (Exception e)
{
Console.WriteLine("Error: \n" + e.StackTrace);
}
}
public void AddChannel(IClientSession channel, IClient connection)
{
AssertUtils.IsTrue(!this.frozen, "Cannot add Channel because RabbitResourceHolder is frozen");
AssertUtils.ArgumentNotNull(channel, "Channel must not be null");
if (!this.channels.Contains(channel))
{
this.channels.Add(channel);
if (connection != null)
{
List <IClientSession> channels = this.channelsPerConnection[connection];
//TODO double check, what about TryGet..
if (channels == null)
{
channels = new List <IClientSession>();
this.channelsPerConnection.Add(connection, channels);
}
channels.Add(channel);
}
}
}
public static long GenerateMessageId(this IClientSession session)
{
if (session.LastMessageId >= 4194303 - 4)
{
session.LastMessageId = 0;
}
else
{
session.LastMessageId += 4;
}
var seconds = (long)DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1)).TotalMilliseconds;
var newMessageId =
((seconds / 1000 + session.TimeOffset) << 32) |
((seconds % 1000) << 22) |
session.LastMessageId;
return(newMessageId);
}
public async Task DataAsItemList()
{
using (var connector = new Connector())
{
IClientSession clientSession = connector.Login("User1", "");
IItem item1 = connector.Tree.GetOrAddItem("Node1\\Node2\\Node3.item1");
Assert.AreEqual("Node1\\Node2\\Node3.item1", item1.Path);
IItem item2 = connector.Tree.GetOrAddItem("Node2\\Node4.item2");
IItem item3 = connector.Tree.GetOrAddItem("Node1\\Node3.item3");
item1.DataAsItemList = new[] { item2, item3 };
await item1.StoreAsync(clientSession);
await item1.LoadAsync();
Assert.AreEqual("Node2\\Node4.item2\nNode1\\Node3.item3", item1.DataAsString);
}
return;
}
public void MessageTransfer(IMessage m)
{
BinaryReader reader = new BinaryReader(m.Body, Encoding.UTF8);
byte[] buffer = new byte[m.Body.Length - m.Body.Position];
reader.Read(buffer, 0, buffer.Length);
string str = new ASCIIEncoding().GetString(buffer);
Console.WriteLine("Message: " + str);
this._range.Add(m.Id);
if (str.Equals("That's all, folks!"))
{
this._session.MessageAccept(this._range, new Option[0]);
IClientSession session = this._session;
lock (session)
{
Monitor.Pulse(this._session);
}
}
}
public void queueLifecycle()
{
_log.Debug("Running: queueLifecycle");
IClientSession ssn = Client.CreateSession(0);
ssn.QueueDeclare("queue1", null, null);
ssn.Sync();
ssn.QueueDelete("queue1");
ssn.Sync();
try
{
ssn.ExchangeBind("queue1", "amq.direct", "queue1", null);
ssn.Sync();
}
catch (SessionException)
{
// as expected
}
// This test fails if an exception is thrown
}
public void BeginConnect(EndPoint serverEndPoint)
{
if (PipeLineProcessor == null)
{
throw new Exception("This client has not been initialized.");
}
m_Session = new AsyncTcpSession(serverEndPoint, 4096);
m_Session.Connected += new EventHandler(m_Session_Connected);
m_Session.Error += new EventHandler <ErrorEventArgs>(m_Session_Error);
m_Session.Closed += new EventHandler(m_Session_Closed);
m_Session.DataReceived += new EventHandler <DataEventArgs>(m_Session_DataReceived);
if (ReceiveBufferSize > 0)
{
m_Session.ReceiveBufferSize = ReceiveBufferSize;
}
m_Session.Connect();
}
public bool rcvMeta(IClientSession session, IMutableMessage message)
{
if (Channel_Fields.META_HANDSHAKE.Equals(message.Channel))
{
Dictionary<String, Object> ext = (Dictionary<String, Object>)message.getExt(false);
_serverSupportsAcks = ext != null && true.Equals(ext[EXT_FIELD]);
}
else if (_serverSupportsAcks && true.Equals(message[Message_Fields.SUCCESSFUL_FIELD]) && Channel_Fields.META_CONNECT.Equals(message.Channel))
{
Dictionary<String, Object> ext = (Dictionary<String, Object>)message.getExt(false);
if (ext != null)
{
Object ack;
ext.TryGetValue(EXT_FIELD, out ack);
_ackId = ObjectConverter.ToInt32(ack, _ackId);
}
}
return true;
}
private static void Main(string[] args)
{
string host = ConfigurationManager.AppSettings["Host"];
int port = int.Parse(ConfigurationManager.AppSettings["Port"]);
string virtualhost = ConfigurationManager.AppSettings["VirtualHost"];
string username = ConfigurationManager.AppSettings["Username"];
string password = ConfigurationManager.AppSettings["Password"];
Client connection = new Client();
try
{
connection.Connect(host, port, virtualhost, username, password);
IClientSession session = connection.CreateSession(50000);
//--------- Main body of program --------------------------------------------
// Create a queue named "message_queue", and route all messages whose
// routing key is "routing_key" to this newly created queue.
session.QueueDeclare("message_queue");
session.ExchangeBind("message_queue", "amq.direct", "routing_key");
lock (session)
{
// Create a listener and subscribe it to the queue named "message_queue"
IMessageListener listener = new MessageListener(session);
session.AttachMessageListener(listener, "message_queue");
session.MessageSubscribe("message_queue");
// Receive messages until all messages are received
Monitor.Wait(session);
}
//---------------------------------------------------------------------------
connection.Close();
}
catch (Exception e)
{
Console.WriteLine("Error: \n" + e.StackTrace);
}
}
public void ReConnect()
{
if (!isStopRequest)
{
ThreadPool.QueueUserWorkItem(o =>
{
if (!isStopRequest)
{
Thread.Sleep(1000);
log.Info("ReConnect");
Connect(this.clientInfo);
if (IsConnected)
{
log.Info("ReSubscribe Topic");
_session = _conn.createSession();
_session.subscribe(topics, this);
}
}
});
}
}
private static void Main(string[] args)
{
string host = ConfigurationManager.AppSettings["Host"];
int port = int.Parse(ConfigurationManager.AppSettings["Port"]);
string virtualhost = ConfigurationManager.AppSettings["VirtualHost"];
string username = ConfigurationManager.AppSettings["Username"];
string password = ConfigurationManager.AppSettings["Password"];
Client connection = new Client();
try
{
connection.Connect(host, port, virtualhost, username, password);
IClientSession session = connection.CreateSession(50000);
//--------- Main body of program --------------------------------------------
lock (session)
{
Console.WriteLine("Listening for messages ...");
// Create a listener
prepareQueue("usa", "usa.#", session);
prepareQueue("europe", "europe.#", session);
prepareQueue("news", "#.news", session);
prepareQueue("weather", "#.weather", session);
while (_count > 0)
{
Monitor.Wait(session);
}
}
//---------------------------------------------------------------------------
connection.Close();
}
catch (Exception e)
{
Console.WriteLine("Error: \n" + e.StackTrace);
}
}
/// <summary>
/// Callback method invoked every time a meta message is being sent.
/// </summary>
/// <returns>Always true.</returns>
/// <exception cref="ArgumentNullException"><paramref name="message"/> is null.</exception>
public override bool SendMeta(IClientSession session, IMutableMessage message)
{
if (message == null)
{
throw new ArgumentNullException("message");
}
long now = CurrentTimeMillis();
IDictionary <string, object> timesync
= new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase)
{
{ "tc", now },
{ "l", _lag },
{ "o", _offset }
};
IDictionary <string, object> ext = message.GetExtension(true);
lock (ext) ext[ExtensionField] = timesync;
return(true);
}
// Token: 0x060008F6 RID: 2294 RVA: 0x0001E47C File Offset: 0x0001C67C
private void OnSessionDataReceived(object sender, DataEventArgs e)
{
ProcessResult processResult;
try
{
processResult = this.PipeLineProcessor.Process(new ArraySegment <byte>(e.Data, e.Offset, e.Length));
}
catch (Exception e2)
{
this.OnError(e2);
this.m_Session.Close();
return;
}
if (processResult.State == ProcessState.Error)
{
this.m_Session.Close();
return;
}
if (processResult.State == ProcessState.Cached)
{
IClientSession session = this.m_Session;
if (session != null)
{
IBufferSetter bufferSetter = session as IBufferSetter;
if (bufferSetter != null)
{
bufferSetter.SetBuffer(new ArraySegment <byte>(new byte[session.ReceiveBufferSize]));
}
}
}
if (processResult.Packages != null && processResult.Packages.Count > 0)
{
foreach (IPackageInfo package in processResult.Packages)
{
this.HandlePackage(package);
}
}
}
public IPipelineMessageItem[] GetMessages(IClientSession session, ref int lastMsgSeq, out bool valid)
{
lock (__lockObject)
{
valid = true;
List <IPipelineMessageItem> buffer = null;
if (!_messages.TryGetValue(session.SessionId, out buffer) ||
buffer.Count == 0 ||
buffer[0].Id == lastMsgSeq)
{
return(null);
}
else if (lastMsgSeq > 0 && buffer[buffer.Count - 1].Id > lastMsgSeq)
{
valid = false;
return(null);
}
var lst = lastMsgSeq;
lastMsgSeq = buffer[0].Id;
return(buffer.TakeWhile(i => i.Id > lst).Reverse().ToArray());
}
}
public bool ReceiveMeta(IClientSession session, IMutableMessage message)
{
if (ChannelFields.MetaHandshake.Equals(message.Channel))
{
var ext = (Dictionary <string, object>)message.GetExt(false);
_serverSupportsAcks = ext != null && true.Equals(ext[ExtField]);
}
else if (_serverSupportsAcks && true.Equals(message[MessageFields.SuccessfulField]) && ChannelFields.MetaConnect.Equals(message.Channel))
{
var ext = (Dictionary <string, object>)message.GetExt(false);
if (ext == null)
{
return(true);
}
ext.TryGetValue(ExtField, out var ack);
_ackId = ObjectConverter.ToInt32(ack, _ackId);
}
return(true);
}
public bool send(IClientSession session, IMutableMessage message)
{
return true;
}
public void CloseSession(IClientSession session)
{
this.DisposeSession(session as ClientSession);
}
protected PerfTestClient(Options options)
{
_options = options;
_connection = new Client();
_connection.Connect(options.Broker, options.Port, "test", "guest", "guest");
_session = _connection.CreateSession(50000);
}
// Methods
public MessageListener(IClientSession session)
{
this._session = session;
}
protected void TryToConnect() {
reqsOutstanding = 1 ;
Agent newAgent = new Agent(this,0,"BrokerAgent") ;
Agents.Add(newAgent.AgentKey(), newAgent) ;
client = new Client() ;
client.Connect(url.Hostname, url.Port, null, url.AuthName, url.AuthPassword) ;
clientSession = client.CreateSession(timeout) ;
//clientSession.SetAutoSync(false) ;
string name = System.Text.Encoding.UTF8.GetString(clientSession.GetName()) ;
replyName = "reply-" + name ;
topicName = "topic-" + name ;
clientSession.SetAutoSync(true) ;
Option[] options = new Option[] {Option.EXCLUSIVE, Option.AUTO_DELETE} ;
// This queue is used for responses to messages which are sent.
clientSession.QueueDeclare(replyName,options) ;
clientSession.ExchangeBind(replyName,"amq.direct",replyName) ;
clientSession.AttachMessageListener(this, "rdest") ;
clientSession.MessageSubscribe(replyName,"rdest",MessageAcceptMode.NONE,MessageAcquireMode.PRE_ACQUIRED,null,0,null) ;
clientSession.MessageSetFlowMode("rdest", MessageFlowMode.WINDOW);
clientSession.MessageFlow("rdest", MessageCreditUnit.BYTE, ClientSession.MESSAGE_FLOW_MAX_BYTES);
clientSession.MessageFlow("rdest", MessageCreditUnit.MESSAGE, ClientSession.MESSAGE_FLOW_MAX_BYTES);
// This queue is used for unsolicited messages sent to this class.
clientSession.QueueDeclare(topicName, options) ;
clientSession.AttachMessageListener(this, "tdest") ;
clientSession.MessageSubscribe(topicName,"tdest",MessageAcceptMode.NONE,MessageAcquireMode.PRE_ACQUIRED,null,0,null) ;
clientSession.MessageSetFlowMode("tdest", MessageFlowMode.WINDOW);
clientSession.MessageFlow("tdest", MessageCreditUnit.BYTE, ClientSession.MESSAGE_FLOW_MAX_BYTES);
clientSession.MessageFlow("tdest", MessageCreditUnit.MESSAGE, ClientSession.MESSAGE_FLOW_MAX_BYTES);
outSession = client.CreateSession(timeout) ;
outSession.ExchangeBind(replyName,"amq.direct",replyName) ;
connected = true ;
consoleSession.HandleBrokerConnect(this) ;
IEncoder encoder = CreateEncoder() ;
this.SetHeader(encoder, 'B', 0) ;
this.Send(encoder) ;
}
public MyListener(IClientSession session, object wl)
{
_wl = wl;
_session = session;
_count = 0;
}
public bool ContainsChannel(IClientSession channel)
{
return channels.Contains(channel);
}
public QpidResourceHolder(IClientSession channel)
{
AddChannel(channel);
this.frozen = true;
}
public QpidResourceHolder(IClient connection, IClientSession channel)
{
AddConnection(connection);
AddChannel(channel, connection);
this.frozen = true;
}
public ClientMessageListener(IClientSession session)
{
_session = session;
}
public void AddChannel(IClientSession channel)
{
AddChannel(channel, null);
}
internal void Singin(IClientSession client)
{
this.Status = ChatUserStatus.Online;
if (_sessions.AddIfNotExists(client))
{
client.Closing += new EventHandler<EventArgs>(client_Closing);
BroadcastStatus();
}
}
public static bool IsChannelTransactional(IClientSession session, IClientFactory clientFactory )
{
//TODO implement
return false;
}
/// <summary>
/// Called when Excel requests the first RTD topic for the server.
/// Connect to the broker, returns a on success and 0 otherwise
/// </summary>
/// <param name="CallbackObject"></param>
/// <returns></returns>
public int ServerStart(IRTDUpdateEvent CallbackObject)
{
_onMessage = CallbackObject;
string host = "localhost";
string port = "5673";
string virtualhost = "test";
string username = "******";
string password = "******";
_messageProcessor = getMessage;
if( ConfigurationManager.AppSettings["Host"] != null )
{
host = ConfigurationManager.AppSettings["Host"];
}
if (ConfigurationManager.AppSettings["Port"] != null)
{
port = ConfigurationManager.AppSettings["Port"];
}
if (ConfigurationManager.AppSettings["VirtualHost"] != null)
{
virtualhost = ConfigurationManager.AppSettings["VirtualHost"];
}
if (ConfigurationManager.AppSettings["Username"] != null)
{
username = ConfigurationManager.AppSettings["UserName"];
}
if (ConfigurationManager.AppSettings["Password"] != null)
{
password = ConfigurationManager.AppSettings["Password"];
}
if (ConfigurationManager.AppSettings["ProcessorAssembly"] != null)
{
try
{
Assembly a = Assembly.LoadFrom(ConfigurationManager.AppSettings["ProcessorAssembly"]);
Object o = a.CreateInstance(ConfigurationManager.AppSettings["ProcessorClass"]);
MessageProcessor p = (MessageProcessor) o;
_messageProcessor = p.ProcessMessage;
}
catch (Exception e)
{
System.Windows.Forms.MessageBox.Show("Error: \n" + e.StackTrace);
return 0;
}
}
System.Windows.Forms.MessageBox.Show("Connection parameters: \n host: " + host + "\n port: "
+ port + "\n user: "******"Error: \n" + e.StackTrace);
return 0;
}
// always successful
return 1;
}
public void BeginConnect(EndPoint remoteEndPoint)
{
if (PipeLineProcessor == null)
throw new Exception("This client has not been initialized.");
var session = GetUnderlyingSession();
var localEndPoint = m_EndPointToBind;
if (localEndPoint != null)
{
session.LocalEndPoint = localEndPoint;
}
session.NoDelay = NoDelay;
if (Proxy != null)
session.Proxy = Proxy;
session.Connected += new EventHandler(OnSessionConnected);
session.Error += new EventHandler<ErrorEventArgs>(OnSessionError);
session.Closed += new EventHandler(OnSessionClosed);
session.DataReceived += new EventHandler<DataEventArgs>(OnSessionDataReceived);
if (ReceiveBufferSize > 0)
session.ReceiveBufferSize = ReceiveBufferSize;
m_Session = session;
session.Connect(remoteEndPoint);
}
private TaskCompletionSource<bool> InitConnect(EndPoint remoteEndPoint)
{
var session = GetUnderlyingSession();
#if !SILVERLIGHT
var localEndPoint = m_EndPointToBind;
if (localEndPoint != null)
{
session.LocalEndPoint = m_EndPointToBind;
}
#endif
#if !__IOS__
session.NoDelay = NoDelay;
#endif
if (Proxy != null)
session.Proxy = Proxy;
session.Connected += new EventHandler(OnSessionConnected);
session.Error += new EventHandler<ErrorEventArgs>(OnSessionError);
session.Closed += new EventHandler(OnSessionClosed);
session.DataReceived += new EventHandler<DataEventArgs>(OnSessionDataReceived);
if (ReceiveBufferSize > 0)
session.ReceiveBufferSize = ReceiveBufferSize;
m_Session = session;
var taskSrc = m_ConnectTaskSource = new TaskCompletionSource<bool>();
session.Connect(remoteEndPoint);
return taskSrc;
}
public void onMessage(IClientSession session, String channel, Cometd.Bayeux.IMessage message)
{
if (message.Successful)
{
Console.WriteLine("had something on " + message.Channel);
Console.WriteLine("namely " + message.JSON);
}
if (channel.Equals("/do/select")) //|| (message is AlexRangeRequest)
{
}
if (channel.Equals("/get/data"))
{
//call Alex_API from here
}
}
private void SetSessionByUser(string login, IClientSession session, bool setting)
{
List<IClientSession> buffer = null;
if (!_sessionsByUser.TryGetValue(login, out buffer))
buffer = _sessionsByUser[login] = new List<IClientSession>();
if (setting)
buffer.Add(session);
else
buffer.Remove(session);
}
public SyncListener(IClientSession session, CircularBuffer<IMessage> buffer)
{
_buffer = buffer;
_session = session;
}
public void AddChannel(IClientSession channel, IClient connection)
{
AssertUtils.IsTrue(!this.frozen, "Cannot add Channel because RabbitResourceHolder is frozen");
AssertUtils.ArgumentNotNull(channel, "Channel must not be null");
if (!this.channels.Contains(channel))
{
this.channels.Add(channel);
if (connection != null)
{
List<IClientSession> channels = this.channelsPerConnection[connection];
//TODO double check, what about TryGet..
if (channels == null)
{
channels = new List<IClientSession>();
this.channelsPerConnection.Add(connection, channels);
}
channels.Add(channel);
}
}
}