/// <summary>
/// Create new changeflag request
/// </summary>
/// <param name="msg"></param>
/// <param name="flag"></param>
/// <param name="value"></param>
/// <param name="callback"></param>
public ChangeFlagRequest(IMessage msg, MessageFlag flag, bool value, RequestCompletedCallback callback)
: base(callback)
{
PreCommand = new SelectFolderCommand(msg.Folder, null);
Command = new ChangeFlagCommand(msg, flag, value, null);
ProcessorType = typeof(ChangeFlagProcessor);
}
/// <summary>
///
/// </summary>
/// <param name="ipEndPoint"></param>
/// <param name="flag"></param>
/// <param name="evt"></param>
/// <param name="cableId"></param>
/// <param name="channel"></param>
/// <param name="data"></param>
/// <exception cref="TcpException"></exception>
/// <exception cref="socketException"></exception>
private void InnerASendResponse(IPEndPoint ipEndPoint, MessageFlag flag, UInt32 evt, UInt16 cableId, UInt32 channel, byte[] data)
{
SCB scb = GetSCB(ipEndPoint);
//scb.AsyncSend(flag, evt, cableId, channel, data);
scb.ASendFromServer(flag, evt, cableId, channel, data);
}
internal void ASendFromServer(MessageFlag flag, UInt32 evt, UInt16 cableId, UInt32 channel, byte[] data)
{
while (BufferLength > 10 * 1024 * 1024)
{
System.Threading.Thread.Sleep(1);
}
Server.SendMessageTask task = _Listener.GetTask(this);
bool needSetEvent = false;
lock (task.LockObj)
{
needSetEvent = task.IncTotalQueueCount(1) == 0;
lock (_QueueLockObj)
{
IncBufferLength(data.Length);
_Queue.Enqueue(new Message(flag, evt, cableId, channel, data));
}
}
if (needSetEvent)
{
task.Event.Set();
}
}
/// <summary>
/// Create new changeflag request
/// </summary>
/// <param name="msg"></param>
/// <param name="flag"></param>
/// <param name="value"></param>
/// <param name="callback"></param>
public ChangeFlagRequest(IMessage msg, MessageFlag flag, bool value, RequestCompletedCallback callback)
: base(callback)
{
PreCommand = new SelectFolderCommand(msg.Folder, null);
Command = new ChangeFlagCommand(msg, flag, value, null);
ProcessorType = typeof (ChangeFlagProcessor);
}
internal void AsyncSend(MessageFlag flag, UInt32 evt, UInt16 cableId, UInt32 channel, byte[] data)
{
if (_SetThreadAffinityMask && (flag | MessageFlag.Sync) != 0)
{
if (PCombine != null)
{
PCombine.Hit();
}
}
while (BufferLength > 10 * 1024 * 1024)
{
System.Threading.Thread.Sleep(1);
}
bool needSetEvent = false;
lock (_LockObj)
{
needSetEvent = _Queue.Count == 0;
IncBufferLength(data.Length);
_Queue.Enqueue(new Message(flag, evt, cableId, channel, data));
}
if (needSetEvent)
{
_Event.Set();
}
}
public virtual void Update(MessageJsonModel model)
{
if (_transientAuthor != null)
{
if (model.Member.HasValue)
{
model.Member.Value.User = model.Author;
_transientAuthor = new TransientMember(Client, GuildId.Value, model.Member.Value);
}
else
{
_transientAuthor = new TransientUser(Client, model.Author);
}
}
Content = model.Content;
MentionedUsers = model.Mentions.ToReadOnlyList(Client, (x, client) =>
{
var user = client.GetUser(x.Id);
if (user != null)
{
return(user);
}
return(new TransientUser(client, x) as IUser);
});
Reactions = Optional.Convert(model.Reactions, models => models.ToReadOnlyDictionary(
x => TransientEmoji.Create(x.Emoji),
x => new TransientMessageReaction(x) as IMessageReaction));
Flags = model.Flags.GetValueOrDefault();
}
/// <summary>
/// Serializes the packet into a byte array, allowing it to be sent over a socket.
/// </summary>
/// <param name="Flags">The MessageFlag corresponding to the message's Ultravox class and type.</param>
/// <param name="PayloadData">The payload for the packet itself.</param>
/// <returns></returns>
public static byte[] Serialize(MessageFlag Flags, byte[] PayloadData)
{
byte[] UltravoxMessage = new byte[] { 0x5A, 0x0, 0x0, 0x0, 0x0, 0x0 };
byte[] LengthBytes = BitConverter.GetBytes((Int16)(PayloadData.Length));
if (BitConverter.IsLittleEndian)
{
byte[] FlagBytes = BitConverter.GetBytes((Int16)(Flags)).Reverse().ToArray();
Flags = (MessageFlag)(BitConverter.ToInt16(FlagBytes, 0));
LengthBytes = LengthBytes.Reverse().ToArray();
}
Buffer.BlockCopy(BitConverter.GetBytes((short)(Flags)), 0, UltravoxMessage, 2, 2);
if (PayloadData.Length > 255)
{
Buffer.BlockCopy(LengthBytes, 0, UltravoxMessage, 4, 2);
}
else
{
UltravoxMessage[5] = Convert.ToByte(PayloadData.Length);
}
byte[] FinalBytes = new byte[UltravoxMessage.Length + PayloadData.Length + 1];
Buffer.BlockCopy(UltravoxMessage, 0, FinalBytes, 0, UltravoxMessage.Length);
Buffer.BlockCopy(PayloadData, 0, FinalBytes, UltravoxMessage.Length, PayloadData.Length);
UltravoxMessage = new byte[] { 0x5A, 0x0, 0x0, 0x0, 0x0, 0x0 };
return(FinalBytes);
}
/// <summary>
/// 序列化并发送消息，如果序列化异常标记消息为错误状态仍旧发送,接收端根据消息类型是请求还是响应作不同处理
/// </summary>
public void SendMessage <T>(ref T msg) where T : struct, IMessage
{
//Log.Debug($"[{System.Diagnostics.Process.GetCurrentProcess().ProcessName}]发送:{msg.Type}");
MessageFlag flag = MessageFlag.None;
int msgId = Interlocked.Increment(ref sendMsgIdIndex);
ulong sourceId = 0; //TODO: fix
var mws = MessageWriteStream.ThreadInstance;
mws.Reset(msg.Type, msgId, sourceId, flag, _sendQueue);
BinSerializer bs = BinSerializer.ThreadInstance;
bs.Init(mws);
try
{
bs.Write((byte)msg.PayloadType); //不用bs.Serialize(msg)防止box
msg.WriteObject(bs);
mws.FinishWrite();
}
catch (Exception ex)
{
//发生异常，则通知接收端取消挂起的消息
unsafe
{
SendCancelMessage(mws.CurrentChunk);
}
//重新抛出异常
Log.Warn(ExceptionHelper.GetExceptionDetailInfo(ex));
throw new MessageSerializationException(MessageSerilizationErrorCode.SerializeFail, ex);
}
finally
{
bs.Clear();
}
}
public async Task <Message> MethodCallAsync(BusAttachment bus, string ifaceName, string methodName, MsgArg args, uint numArgs,
TimeSpan timeout, MessageFlag flags = 0)
{
if (timeout.Ticks < 0)
{
throw new ArgumentOutOfRangeException(nameof(timeout));
}
var replyMsg = Message.alljoyn_message_create(bus.Handle);
TaskCompletionSource <Message> tcs = new TaskCompletionSource <Message>();
alljoyn_messagereceiver_replyhandler_ptr replyFunc = (a, b) =>
{
tcs.SetResult(new Message(a));
};
var handle = GCHandle.Alloc(replyFunc);
AllJoynException.CheckStatus(
alljoyn_proxybusobject_methodcallasync(Handle, ifaceName, methodName, replyFunc, args.Handle,
(UIntPtr)numArgs, replyMsg, (uint)timeout.TotalMilliseconds, (byte)flags)
);
Message message;
try
{
message = await tcs.Task;
}
finally
{
handle.Free();
}
return(message);
}
public Message(int evt, MessageFlag flag, object data)
{
Event = evt;
Flag = flag;
Data = data;
_SSendEvent = null;
RetData = null;
}
public MessageAttribute(string text, MessageFlag messageFlags = MessageFlag.HasText, bool regex = false)
: this()
{
isRegex = regex;
InChat = InChat.All;
Text = text;
MessageFlags = messageFlags;
}
public Message(int evt, MessageFlag flag, object data, System.Threading.ManualResetEvent ssendEvent)
{
Event = evt;
Flag = flag;
Data = data;
_SSendEvent = ssendEvent;
RetData = null;
}
public bool HasFlag(string command, MessageFlag flag)
{
if (msgFlags.TryGetValue(command, out MessageFlag flags))
{
return(flags.HasFlag(flag));
}
return(false);
}
public Message(MessageFlag flag, UInt32 evt, UInt16 cableId,
UInt32 channel, byte[] data)
{
this.Flag = flag;
this.Event = evt;
this.CableId = cableId;
this.Channel = channel;
this.Data = data;
}
public InsteonStandardMessage(DeviceAddress sourceAddress, DeviceAddress targetAddress, byte command1, byte command2, byte flagByte)
{
_sourceAddress = sourceAddress;
_targetAddress = targetAddress;
_command1 = command1;
_command2 = command2;
_flag = (MessageFlag)(flagByte & ((byte)0xE0));
_flagByte = flagByte;
}
public SearchHistoryEntry(Search.Options searchOptions)
{
Template = searchOptions.Template ?? "";
WholeWord = searchOptions.WholeWord;
Regexp = searchOptions.Regexp;
MatchCase = searchOptions.MatchCase;
TypesToLookFor = searchOptions.ContentTypes;
this.normalizedTemplate = !MatchCase?Template.ToLower() : Template;
}
public Message(IPAddress target, MessageType type, MessageFlag flag, int group = 0)
{
Identifier = MessageId.GetNextIdentifier();
Target = target;
Type = type;
Flag = flag;
Group = group;
Payload = new Payload();
_data = Encode();
}
public static string flagToString(MessageFlag flag)
{
try
{
return ReverseMap[flag];
}
catch (KeyNotFoundException)
{
return string.Empty;
}
}
public ReceiveEventArgs(int scbId, EndPoint remoteIPEndPoint, MessageFlag flag, UInt32 evt, UInt16 cableId, UInt32 channel, byte[] data)
{
SCBID = scbId;
RemoteIPEndPoint = remoteIPEndPoint;
Flag = flag;
Event = evt;
CableId = cableId;
Channel = channel;
Data = data;
ReturnData = null;
}
public void SetFlag(string command, MessageFlag flag)
{
if (msgFlags.TryGetValue(command, out MessageFlag flags))
{
msgFlags[command] = flags | flag;
}
else
{
msgFlags.Add(command, flag);
}
}
/// <summary>
/// Send syncronization message
/// </summary>
/// <param name="evt">event</param>
/// <param name="cableId">cableId no</param>
/// <param name="data">data need to send</param>
/// <param name="timeout">waitting timeout. In millisecond</param>
/// <returns>data return from client</returns>
private byte[] InnerSSend(MessageFlag flag, UInt32 evt, UInt16 cableId, byte[] data, int timeout)
{
if (!Connected)
{
throw new NTcpException("Tcp disconnected", ErrorCode.Disconnected);
}
SyncBlock syncBlock;
UInt32 channel = GetChannelForSync(out syncBlock);
_SendMessageQueue.AsyncSend(flag, evt, cableId, channel, data);
bool bSuccess;
byte[] retData;
try
{
bSuccess = syncBlock.WaitOne(timeout);
if (bSuccess)
{
if (!Connected)
{
throw new NTcpException("Tcp disconnected during ssend", ErrorCode.Disconnected);
}
retData = syncBlock.RetData;
}
}
catch (NTcpException)
{
throw;
}
catch (Exception e)
{
throw new NTcpException(string.Format("Tcp disconnected during ssend, err:{0}",
e), ErrorCode.Disconnected);
}
finally
{
syncBlock.Close();
ReturnChannelForSync(channel);
}
if (bSuccess)
{
return(syncBlock.RetData);
}
else
{
throw new TimeoutException("SyncSend timeout!");
}
}
/// <summary>
/// Create a new ChangeFlag command
/// </summary>
/// <param name="msg"></param>
/// <param name="flag"></param>
/// <param name="value"></param>
/// <param name="callback"></param>
public ChangeFlagCommand(IMessage msg, MessageFlag flag, bool value, CommandDataReceivedCallback callback)
: base(callback)
{
// UID STORE 4963 -FLAGS (\Seen)
const string cmd = "UID STORE {0} {1}FLAGS (\\{2})";
_parameters.Add(msg.UID.ToString());
_parameters.Add(value ? "+":"-");
_parameters.Add(flag.ToString());
_parameterObjs.Add(msg);
CommandString = String.Format(cmd, Parameters);
}
private void OnReceiveEvent(SCB scb, MessageFlag flag, UInt32 evt, UInt16 cableId,
UInt32 channel, byte[] data)
{
SyncBlock syncBlock;
if ((flag & MessageFlag.Sync) != 0)
{
if (channel > int.MaxValue)
{
//server side ssend
EventHandler <Event.ReceiveEventArgs> receiveEventHandler = ReceiveEventHandler;
if (receiveEventHandler != null)
{
try
{
Event.ReceiveEventArgs args = new Event.ReceiveEventArgs(scb.Id,
scb.RemoteIPEndPoint, flag, evt, cableId, channel, data);
receiveEventHandler(this, args);
InnerASend(flag, evt, cableId, args.ReturnData);
}
catch
{
}
}
}
else if (TryGetSyncChannel(channel, out syncBlock))
{
syncBlock.RetData = data;
syncBlock.AutoEvent.Set();
}
}
else
{
EventHandler <Event.ReceiveEventArgs> receiveEventHandler = ReceiveEventHandler;
if (receiveEventHandler != null)
{
try
{
receiveEventHandler(this, new Event.ReceiveEventArgs(scb.Id,
scb.RemoteIPEndPoint, flag, evt, cableId, channel, data));
}
catch
{
}
}
}
}
MessageFlag GetTypes(List <bool> typesCheckboxesValues)
{
MessageFlag f = MessageFlag.None;
for (int i = 0; i < Math.Min(typeFlagsList.Length, typesCheckboxesValues.Count); ++i)
{
if (typesCheckboxesValues[i])
{
f |= typeFlagsList[i];
}
}
return(f);
}
public MessageFlag HighestMessageFlag()
{
MessageFlag high = MessageFlag.None;
foreach (var f in m_MessageSet)
{
if (f > high)
{
high = f;
}
}
return(high);
}
/// <summary>
/// Create a new ChangeFlag command
/// </summary>
/// <param name="msg"></param>
/// <param name="flag"></param>
/// <param name="value"></param>
/// <param name="callback"></param>
public ChangeFlagCommand(IMessage msg, MessageFlag flag, bool value, CommandDataReceivedCallback callback)
: base(callback)
{
// UID STORE 4963 -FLAGS (\Seen)
const string cmd = "UID STORE {0} {1}FLAGS (\\{2})";
_parameters.Add(msg.UID.ToString());
_parameters.Add(value ? "+":"-");
_parameters.Add(flag.ToString());
_parameterObjs.Add(msg);
CommandString = String.Format(cmd, Parameters);
}
private void OnReceiveEvent(SCB scb, MessageFlag flag, UInt32 evt, UInt16 cableId,
UInt32 channel, byte[] data)
{
EventHandler <Event.ReceiveEventArgs> receiveEventHandler = DataReceived;
if (receiveEventHandler != null)
{
Event.ReceiveEventArgs args = new Event.ReceiveEventArgs(scb.Id,
scb.RemoteIPEndPoint, flag, evt, cableId, channel, data);
_WorkThreads[scb.Id % _WorkThreads.Length].ASendMessage(args);
}
}
/// <summary>
///
/// </summary>
/// <param name="flag"></param>
/// <param name="evt"></param>
/// <param name="group"></param>
/// <param name="channel"></param>
/// <param name="data"></param>
/// <exception cref="TcpException"></exception>
/// <exception cref="socketException"></exception>
private void ASend(MessageFlag flag, UInt32 evt, UInt16 group, byte[] data)
{
if (!Connected)
{
throw new NTcpException("Tcp disconnected", ErrorCode.Disconnected);
}
IncCurChannel();
_SendMessageQueue.ASend(flag, evt, group, CurChannel, data);
//SCB scb = _SCB;
//scb.ASend(flag, evt, group, channel, data);
}
public unsafe void Reset(MessageType msgType, int msgID, ulong sourceId, MessageFlag msgFlag, SharedMessageQueue queue = null)
{
_curChunk = null; //必须设置，否则缓存重用有问题
_msgType = msgType;
_msgID = msgID;
_sourceId = sourceId;
_msgFlag = msgFlag;
_queue = queue;
CreateChunk();
//第一包设MessageSource
//_curChunk->MessageSource = srcType;
}
public Message MethodCall(BusAttachment bus, string ifaceName, string methodName, MsgArg args,
uint numArgs, TimeSpan timeout, MessageFlag flags = 0)
{
if (timeout.Ticks < 0)
{
throw new ArgumentOutOfRangeException(nameof(timeout));
}
var replyMsg = new Message(bus);
AllJoynException.CheckStatus(
alljoyn_proxybusobject_methodcall(Handle, ifaceName, methodName, args.Handle,
(UIntPtr)numArgs, replyMsg.Handle, (uint)timeout.TotalMilliseconds, (byte)flags)
);
return(replyMsg);
}
public static Message GetMessage(MessageFlag lookup)
{
if (m_MessageLookup == null)
{
InitMessages();
}
Message msg = null;
m_MessageLookup.TryGetValue(lookup, out msg);
if (msg == null)
{
msg = m_MessageLookup[MessageFlag.None];
}
return(msg);
}
public void SetFlag(MessageFlag flag, bool on)
{
if (flag == MessageFlag.Info || flag == MessageFlag.Warning || flag == MessageFlag.Error)
{
return;
}
if (on)
{
m_MessageFlags |= flag;
m_MessageSet.Add(flag);
}
else
{
m_MessageFlags &= ~flag;
m_MessageSet.Remove(flag);
}
}
/// <summary>
/// Inner Asend to the client specified in ipEndPoint.
/// </summary>
/// <param name="flag"></param>
/// <param name="evt"></param>
/// <param name="cableId"></param>
/// <param name="channel"></param>
/// <param name="data"></param>
/// <exception cref="TcpException"></exception>
/// <exception cref="socketException"></exception>
private bool InnerASend(IPEndPoint ipEndPoint, MessageFlag flag, UInt32 evt, UInt16 cableId, byte[] data)
{
SCB scb = GetSCB(ipEndPoint);
if (scb == null)
{
return(false);
}
IncCurChannel();
//scb.AsyncSend(flag, evt, cableId, channel, data);
scb.ASendFromServer(flag, evt, cableId, CurChannel, data);
return(true);
//SCB scb = _SCB;
//scb.AsyncSend(flag, evt, cableId, channel, data);
}
private void SetPayloadLength(uint payloadLength)
{
if (payloadLength <= 255)
{
if (!MessageFlag.HasFlag(MessageFlag.ShortRecord))
{
MessageFlag |= MessageFlag.ShortRecord;
}
}
else
{
if (MessageFlag.HasFlag(MessageFlag.ShortRecord))
{
MessageFlag &= ~MessageFlag.ShortRecord;
}
}
_payloadLength = payloadLength;
}
/// <summary>
///
/// </summary>
/// <param name="msg"></param>
/// <param name="flag"></param>
/// <param name="value"></param>
/// <param name="localOnly">Indicates if the flag should be set only on the local object, and not on the server</param>
public void SetMessageFlag(IMessage msg, MessageFlag flag, bool value, bool localOnly)
{
bool currentValue = _client.DataManager.GetValue<Message, bool>((Message)msg, flag.ToString());
if (currentValue == value) return;
_client.DataManager.SetValue(msg, flag.ToString(), value);
if (localOnly) return;
ChangeFlagRequest cfr = new ChangeFlagRequest(msg, flag, value, null);
_client.RequestManager.SubmitRequest(cfr, true);
}
/// <summary>
///
/// </summary>
/// <param name="msg"></param>
/// <param name="flag"></param>
/// <param name="value"></param>
/// <param name="localOnly">Indicates if the flag should be set only on the local object, and not on the server</param>
public bool SetMessageFlag(IMessage msg, MessageFlag flag, bool value, bool localOnly)
{
bool currentValue = _client.DataManager.GetValue<Message, bool>((Message)msg, flag.ToString());
if (currentValue == value) return true;
_client.DataManager.SetValue(msg, flag.ToString(), value);
if (localOnly) return true;
ChangeFlagRequest cfr = new ChangeFlagRequest(msg, flag, value, null);
_client.RequestManager.SubmitRequest(cfr, true);
return cfr.Result.Response == IMAPResponse.IMAP_SUCCESS_RESPONSE;
}
