/// <summary>
///
/// </summary>
/// <param name="queue_owner"></param>
/// <param name="queue_type"></param>
/// <param name="issued_host"></param>
/// <returns></returns>
public int QStop(QAgency queue_owner, Type queue_type, string issued_host)
{
var _result = 0;
MessageQueue _pushQ = CreateServiceQueue(Subscriber.GetQueuePath(Subscriber.GetStockerQueueName(queue_owner.QueueName)));
if (_pushQ != null)
{
_pushQ.Formatter = new XmlMessageFormatter(new Type[] { queue_type });
Hashtable _readers = Subscribers.CurrentCacheState;
foreach (DictionaryEntry _q in _readers)
{
CacheItem _citem = _q.Value as CacheItem;
var _agency = _citem.Value as QAgency;
if (String.Compare(_agency.IssuedHost, issued_host, true) != 0)
{
continue;
}
if (SendRemove(queue_owner, _agency) == true)
{
if (WriteStorage(_pushQ, _agency) == true)
{
_result++;
}
}
}
_pushQ.Close();
}
return(_result);
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="agency"></param>
/// <returns></returns>
public bool AddAgency(QAgency sender, QAgency agency)
{
var _result = false;
lock (SyncRoot)
{
var _qpath = QueuePath(agency);
if (Subscribers.Contains(_qpath) == false)
{
if (agency.Certkey == Guid.Empty)
{
agency.Certkey = Guid.NewGuid();
}
agency.IssuedHost = sender.HostName;
Subscribers.Add(_qpath, agency);
_result = true;
}
else
{
agency = Subscribers.GetData(_qpath) as QAgency;
}
SendCertKey(sender, agency);
}
return(_result);
}
/// <summary>
///
/// </summary>
/// <param name="queue_owner"></param>
/// <param name="args"></param>
/// <returns></returns>
public int DoPingTest(QAgency queue_owner, string args)
{
var _result = 0;
foreach (var _q in Subscribers.CurrentCacheState)
{
CacheItem _citem = ((DictionaryEntry)_q).Value as CacheItem;
var _agency = _citem.Value as QAgency;
if (String.Compare(queue_owner.IssuedHost, _agency.IssuedHost, true) != 0)
{
continue;
}
var _qpath = QueuePath(_agency);
_agency.PingRetry++;
if (_agency.PingRetry <= PingRetryMax)
{
SendPing(queue_owner, _agency, args);
Subscribers.Add(_qpath, _agency);
}
else
{
Subscribers.Remove(_qpath);
//SendRemove(queue_owner, _agency);
}
_result++;
}
return(_result);
}
/// <summary>
///
/// </summary>
/// <param name="queue_server"></param>
/// <param name="e"></param>
public void Insert(QAgency queue_server, ReceiveCompletedEventArgs e)
{
var _queuePath = QWriter.QueuePath(queue_server);
Publishers.Add(_queuePath, queue_server);
if (e != null && QInsertEvents != null)
{
QInsertEvents(this, e);
}
}
/// <summary>
///
/// </summary>
public void QStop()
{
foreach (DictionaryEntry _q in Publishers.CurrentCacheState)
{
CacheItem _citem = _q.Value as CacheItem;
QAgency _agency = _citem.Value as QAgency;
QWriter.SendSignOut(QMaster, _agency, _agency.Certkey);
//Remove(_agency);
}
}
/// <summary>
///
/// </summary>
/// <param name="queue_server"></param>
/// <returns></returns>
public Guid Certkey(QAgency queue_server)
{
var _result = Guid.Empty;
var _queuePath = QWriter.QueuePath(queue_server);
if (Publishers.Contains(_queuePath) == true)
{
QAgency _agency = Publishers.GetData(_queuePath) as QAgency;
_result = _agency.Certkey;
}
return(_result);
}
//-----------------------------------------------------------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------------------------------------------------------
private void Remove(QAgency queue_server, ReceiveCompletedEventArgs e)
{
var _queuePath = QWriter.QueuePath(queue_server);
if (Publishers.Contains(_queuePath) == true)
{
Publishers.Remove(_queuePath);
}
if (e != null && QRemoveEvents != null)
{
QRemoveEvents(this, e);
}
}
/// <summary>
///
/// </summary>
/// <param name="queue_server"></param>
public void QStop(QAgency queue_server)
{
Guid _certkey = Certkey(queue_server);
// I will service out using the certification key.
if (_certkey != Guid.Empty)
{
QWriter.SendSignOut(QMaster, queue_server, _certkey);
}
else
{
Remove(queue_server, null);
}
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="reader"></param>
/// <param name="exception"></param>
/// <param name="command"></param>
/// <param name="label"></param>
/// <param name="package"></param>
/// <param name="app_secific"></param>
/// <param name="priority"></param>
/// <returns></returns>
public bool WritePacket(
QAgency sender, QAgency reader, string exception, string command, string label,
XmlPackage package,
int app_secific = 5, System.Messaging.MessagePriority priority = System.Messaging.MessagePriority.Normal
)
{
using (QMessage _qmessage = new QMessage(sender)
{
Command = command,
Package = package,
UsePackage = false
})
{
return(WritePacket(_qmessage, reader, exception, label, app_secific, priority));
}
}
/// <summary>
///
/// </summary>
/// <param name="user_name"></param>
/// <returns></returns>
public QAgency SelectAgencyByUserName(string user_name)
{
QAgency _result = null;
foreach (DictionaryEntry _q in Subscribers.CurrentCacheState)
{
CacheItem _citem = _q.Value as CacheItem;
var _agency = _citem.Value as QAgency;
if (_agency.UserName == user_name)
{
_result = _agency;
break;
}
}
return(_result);
}
/// <summary>
///
/// </summary>
/// <param name="ip_address">IP주소</param>
/// <returns></returns>
public QAgency SelectAgencyByIpAddress(string ip_address)
{
QAgency _result = null;
foreach (DictionaryEntry _q in Subscribers.CurrentCacheState)
{
CacheItem _citem = _q.Value as CacheItem;
var _agency = _citem.Value as QAgency;
if (_agency.IpAddress == ip_address)
{
_result = _agency;
break;
}
}
return(_result);
}
//-----------------------------------------------------------------------------------------------------------------------------
// selection
//-----------------------------------------------------------------------------------------------------------------------------
/// <summary>
///
/// </summary>
/// <param name="client_id"></param>
/// <returns></returns>
public QAgency SelectAgency(Guid client_id)
{
QAgency _result = null;
foreach (DictionaryEntry _q in Subscribers.CurrentCacheState)
{
CacheItem _citem = _q.Value as CacheItem;
var _agency = _citem.Value as QAgency;
if (_agency.Certkey == client_id)
{
_result = _agency;
break;
}
}
return(_result);
}
//-----------------------------------------------------------------------------------------------------------------------------
// packet
//-----------------------------------------------------------------------------------------------------------------------------
/// <summary>
///
/// </summary>
/// <param name="message"></param>
/// <param name="reader"></param>
/// <param name="exception"></param>
/// <param name="label"></param>
/// <param name="app_secific"></param>
/// <param name="priority"></param>
/// <returns></returns>
public bool WritePacket(QMessage message, QAgency reader, string exception, string label, int app_secific, MessagePriority priority)
{
var _result = false;
MessageQueue _messageQ = OpenQueue(QueuePath(reader));
if (_messageQ != null)
{
_messageQ.Formatter = new XmlMessageFormatter(new Type[] { typeof(QMessage) });
//_messageQ.Formatter = new BinaryMessageFormatter();
message.Exception = exception;
message.Connected = CUnixTime.UtcNow;
_result = WriteQueue(_messageQ, message, label, app_secific, priority);
}
return(_result);
}
/// <summary>
///
/// </summary>
/// <param name="queue_owner"></param>
/// <param name="queue_type"></param>
/// <param name="issued_host"></param>
/// <returns></returns>
public int QStart(QAgency queue_owner, Type queue_type, string issued_host)
{
var _result = 0;
MessageQueue _popQ = CreateServiceQueue(Subscriber.GetQueuePath(Subscriber.GetStockerQueueName(queue_owner.QueueName)));
if (_popQ != null)
{
try
{
_popQ.Formatter = new XmlMessageFormatter(new Type[] { queue_type });
Message[] _messages = _popQ.GetAllMessages();
foreach (var _message in _messages)
{
var _agency = _message.Body as QAgency;
if (String.Compare(_agency.IssuedHost, issued_host, true) != 0)
{
continue;
}
if (SendReset(queue_owner, _agency) == true)
{
_result++;
}
}
}
catch (MessageQueueException ex)
{
throw new Exception(ex.MessageQueueErrorCode.ToString(), ex);
}
catch (Exception)
{
}
finally
{
_popQ.Purge();
}
}
return(_result);
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <returns></returns>
public bool SetPingFlag(QAgency sender)
{
var _result = false;
lock (SyncRoot)
{
var _qpath = QueuePath(sender);
if (Subscribers.Contains(_qpath) == true)
{
var _agency = Subscribers.GetData(_qpath) as QAgency;
_agency.PingRetry = 0;
Subscribers.Add(_qpath, _agency);
_result = true;
}
}
return(_result);
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="ip_address">IP주소</param>
/// <returns></returns>
public bool ResetAgency(QAgency sender, string ip_address)
{
var _result = false;
var _agency = SelectAgencyByIpAddress(ip_address);
if (_agency != null)
{
lock (SyncRoot)
{
var _qpath = QueuePath(_agency);
if (Subscribers.Contains(_qpath) == true)
{
Subscribers.Remove(_qpath);
SendReset(sender, _agency);
_result = true;
}
}
}
return(_result);
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="reader"></param>
/// <param name="exception"></param>
/// <param name="command"></param>
/// <param name="label"></param>
/// <param name="message"></param>
/// <param name="kind_of_packing"></param>
/// <param name="crypto_key"></param>
/// <param name="app_secific"></param>
/// <param name="priority"></param>
/// <returns></returns>
public bool WritePacket(
QAgency sender, QAgency reader, string exception, string command, string label,
string message, MKindOfPacking kind_of_packing = MKindOfPacking.None, string crypto_key = "",
int app_secific = 5, MessagePriority priority = MessagePriority.Normal
)
{
var _result = false;
if (String.IsNullOrEmpty(message) == false)
{
using (QMessage _qmessage = new QMessage(sender)
{
Command = command,
Package = Serialization.SNG.WritePackage <string>(message, kind_of_packing, crypto_key),
UsePackage = true
})
{
_result = WritePacket(_qmessage, reader, exception, label, app_secific, priority);
}
}
return(_result);
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="client_id"></param>
/// <returns></returns>
public bool RemoveAgency(QAgency sender, Guid client_id)
{
var _result = false;
var _agency = SelectAgency(client_id);
if (_agency != null)
{
lock (SyncRoot)
{
var _qpath = QueuePath(_agency);
if (Subscribers.Contains(_qpath) == true)
{
Subscribers.Remove(_qpath);
SendRemove(sender, _agency);
_result = true;
}
}
}
return(_result);
}
//-----------------------------------------------------------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------------------------------------------------------
/// <summary>
///
/// </summary>
/// <param name="queue_master"></param>
public QReader(QAgency queue_master)
{
m_qmaster = (QAgency)queue_master.Clone();
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="reader"></param>
/// <param name="exception"></param>
/// <param name="message"></param>
/// <returns></returns>
public bool WriteLogging(QAgency sender, QAgency reader, string exception, string message)
{
return(WriteLogging(sender, reader, exception, "write", message));
}
/// <summary>
///
/// </summary>
/// <param name="queue_server"></param>
/// <param name="args"></param>
/// <param name="open_with_purge"></param>
public void QStart(QAgency queue_server, string args, bool open_with_purge)
{
QStart(open_with_purge);
QWriter.SendSignIn(QMaster, queue_server, args);
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="reader"></param>
/// <param name="message"></param>
/// <returns></returns>
public bool WriteLogging(QAgency sender, QAgency reader, string message)
{
return(WriteLogging(sender, reader, "L", message));
}
/// <summary>
/// MSMQ를 통해 명령-메시지를 직접 전달 합니다.
/// </summary>
/// <param name="sender"></param>
/// <param name="reader"></param>
/// <param name="exception"></param>
/// <param name="command"></param>
/// <param name="message"></param>
/// <returns></returns>
public bool WriteCommand(QAgency sender, QAgency reader, string exception, string command, string message)
{
return(WritePacket(sender, reader, exception, command, "CMD", message, MKindOfPacking.Encrypted, "", 1, MessagePriority.High));
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="reader"></param>
/// <param name="certification_key"></param>
/// <returns></returns>
public bool SendSignOut(QAgency sender, QAgency reader, Guid certification_key)
{
return(WriteCommand(sender, reader, "signout", certification_key.ToString()));
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="reader"></param>
/// <param name="args"></param>
/// <returns></returns>
public bool SendSignIn(QAgency sender, QAgency reader, string args)
{
return(WriteCommand(sender, reader, "signin", args));
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="reader"></param>
/// <param name="args"></param>
/// <returns></returns>
public bool SendPong(QAgency sender, QAgency reader, string args)
{
return(WriteCommand(sender, reader, "pong", args));
}
//-----------------------------------------------------------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------------------------------------------------------
/// <summary>
///
/// </summary>
/// <param name="agency"></param>
/// <returns></returns>
public string QueuePath(QAgency agency)
{
return(GetRemoteQueuePath(agency.Protocol, agency.IpAddress, agency.QueueName));
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="reader"></param>
/// <returns></returns>
public bool SendRemove(QAgency sender, QAgency reader)
{
return(WriteCommand(sender, reader, "remove", reader.Certkey.ToString()));
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="reader"></param>
/// <param name="command"></param>
/// <param name="message"></param>
/// <returns></returns>
public bool WriteCommand(QAgency sender, QAgency reader, string command, string message)
{
return(WriteCommand(sender, reader, "C", command, message));
}
//-----------------------------------------------------------------------------------------------------------------------------
// common
//-----------------------------------------------------------------------------------------------------------------------------
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="agency"></param>
/// <returns></returns>
public bool SendCertKey(QAgency sender, QAgency agency)
{
return(WriteCommand(sender, agency, "certkey", agency.Certkey.ToString()));
}
