public virtual void SendMessageToProxy(PrimaryMessage message)
{
if (message.MessageType == PrimaryMessageType.Ping)
{
message.MessageType = PrimaryMessageType.PingAnswer;
Manager.ReceiveMessage(message);
return;
}
var proxymes = new ProxyMessage();
proxymes.Message = message;
var user = Manager.Users.GetUserFromId(message.MessageRoot.RemoteId);
var serv = Server.Find((server) => server.OwnedUser.Contains(user));
if (user == null || serv == null)
{
message.IgnoreProxy = true;
Manager.SendMessage(message);
}
else
{
proxymes.TargetId = user.GlobalId;
proxymes.MessageRoot.SetFromUser(serv.ServerUser);
var pm = new PrimaryMessage();
pm.ClientData.SetMessage(proxymes);
pm.MessageType = PrimaryMessageType.ProxySend;
pm.MessageRoot.SetFromUser(serv.ServerUser);
Manager.SendMessage(pm);
}
}
public void SendPushMessage(Message message)
{
var pm = new PrimaryMessage();
pm.MessageType = PrimaryMessageType.NormalPush;
pm.ClientData.SetMessage(message);
SendMessage(pm);
}
public virtual void FetchUser(User serverUser)
{
var pm = new PrimaryMessage();
pm.IgnoreProxy = false;
pm.MessageRoot.SetFromUser(serverUser);
pm.MessageType = PrimaryMessageType.ProxyFetchList;
Manager.SendMessage(pm);
}
public virtual bool IsProxyRequired(PrimaryMessage message)
{
if (message.IgnoreProxy)
{
return(false);
}
var user = Manager.Users.GetUserFromId(message.MessageRoot.RemoteId);
return(user != null && user.IsProxy);
}
protected void MessageReceived(PrimaryMessage message)
{
message.MessageRoot.Connector = ConnectorId;
if (Manager != null)
{
Manager.ReceiveMessage(message);
}
if (_MesRec != null)
{
_MesRec(message);
}
}
public void SendMessage(PrimaryMessage message)
{
message.SenderID = CurrentId.Id;
if (Proxy.IsProxyRequired(message))
{
Proxy.SendMessageToProxy(message);
}
else
{
connectors.Find((c) => c.ConnectorId == message.MessageRoot.Connector).SendMessage(message);
}
}
public virtual void SendUserList(PrimaryMessage message)
{
var user = Manager.Users.GetUserFromId(message.SenderID) ?? AddProxyUser(message.MessageRoot.RemoteId, message.SenderID);
var l = new List <byte>();
foreach (var u in Manager.Users.Users.ToArray())
{
if (u != user)
{
l.AddRange(u.GlobalId);
}
}
var pm = new PrimaryMessage();
pm.ClientData.SetBinary(l.ToArray());
pm.MessageRoot.SetFromUser(user);
pm.MessageType = PrimaryMessageType.ProxySendList;
Manager.SendMessage(pm);
}
public virtual void ReceiveUserList(PrimaryMessage message)
{
var user = Manager.Users.GetUserFromId(message.SenderID) ?? AddProxyUser(message.MessageRoot.RemoteId, message.SenderID);
var serv = Server.Find((ps) => ps.ServerUser == user || ps.OwnedUser.Contains(user));
if (serv == null)
{
Server.Add(serv = new ProxyServer()
{
ServerUser = user
});
}
var b = message.ClientData.GetBinary().ToList();
for (var i = 0; i < b.Count; i += 16)
{
var id = b.GetRange(i, 16).ToArray();
var rm = Manager.Users.GetUserFromId(id);
//if (rm==null) serv.OwnedUser.Add(AddProxyUser()) //dringend weiterprogrammieren!!!
}
}
public virtual void ReceivedMessageAsProxy(PrimaryMessage message)
{
var proxymes = message.ClientData.GetMessage <ProxyMessage>();
if (!ProxyMessageReceived(proxymes))
{
return;
}
var isTarget = IdEquals(Manager.CurrentId.Id, proxymes.TargetId);
if (isTarget)
{
if (!ProxyMessageInTarget(proxymes))
{
return;
}
var user = Manager.Users.GetUserFromId(proxymes.Message.SenderID) ?? AddProxyUser(message.MessageRoot.RemoteId, message.SenderID); //message.SenderID???
proxymes.MessageRoot.RemoteId = user.Id;
Manager.ReceiveMessage(proxymes.Message);
}
else
{
if (!SendProxyMessageToTarget(proxymes))
{
return;
}
var user = Manager.Users.GetUserFromId(proxymes.TargetId) ?? AddProxyUser(message.MessageRoot.RemoteId, message.SenderID); //message.SenderID???
var serv = Server.Find((server) => server.OwnedUser.Contains(user));
if (serv == null)
{
return;
}
proxymes.MessageRoot.SetFromUser(serv.ServerUser);
var pm = new PrimaryMessage();
pm.ClientData.SetMessage(proxymes);
pm.MessageType = PrimaryMessageType.ProxySend;
pm.MessageRoot.SetFromUser(serv.ServerUser);
Manager.SendMessage(pm);
}
}
public void SendMessage(Message message)
{
var ppm = new PipelineMessage();
ppm.more = message is PipelineMessage;
ppm.ID = GlobalId;
ppm.MessageRoot = message.MessageRoot;
ppm.ClientData.SetMessage(message);
if (Owner != null)
{
Owner.SendMessage(ppm);
}
else
{
var pm = new PrimaryMessage();
pm.MessageType = PrimaryMessageType.Pipeline;
pm.SenderID = Manager.CurrentId.Id;
pm.ClientData.SetMessage(ppm);
pm.MessageRoot = message.MessageRoot;
Manager.SendMessage(pm);
}
}
public virtual void SendMessage(PrimaryMessage message)
{
}
public void ReceiveMessage(PrimaryMessage message)
{
var t = new System.Threading.Tasks.Task(() =>
{
switch (message.MessageType)
{
case PrimaryMessageType.NormalPush:
if (PushMessageReceived != null)
{
PushMessageReceived(message.ClientData.GetMessage <Message>());
}
break;
case PrimaryMessageType.Pipeline:
var pipe = MessagePipelines.Find((mp) => mp.GlobalId == message.ClientData.GetMessage <PipelineMessage>().ID);
if (pipe != null)
{
pipe.ComputeMessage(message.ClientData.GetMessage <PipelineMessage>());
}
break;
case PrimaryMessageType.FileTransportClientToServer:
if (defaultFileTransport != null)
{
defaultFileTransport.SendMessage(message);
}
break;
case PrimaryMessageType.FileTransportServerToClient:
if (defaultFileTransport != null)
{
defaultFileTransport.SendMessage(message);
}
break;
case PrimaryMessageType.SyncFile:
if (SyncFile != null)
{
var mes = message.ClientData.GetMessage <Connectors.Sync.SyncFileMessage>();
SyncFile.MessageReceived(mes);
}
break;
case PrimaryMessageType.SyncData:
{
var sd = message.ClientData.GetMessage <AutoSync.SyncMessage>();
var dat = sd.ClientData.GetSerializeAble <AutoSync.SyncMessageData>();
var man = SyncData.Find((sm) => sm.Id == dat.SyncManagerId);
if (man != null)
{
man.MessageReceived(sd);
}
} break;
case PrimaryMessageType.Ping:
{
message.MessageType = PrimaryMessageType.PingAnswer;
SendMessage(message);
} break;
case PrimaryMessageType.PingAnswer:
{
var time = BitConverter.ToInt32(message.ClientData.GetBinary(), 0);
var user = Users.GetUserFromId(message.SenderID);
if (user != null)
{
user.Ping = Environment.TickCount - time;
}
} break;
case PrimaryMessageType.ProxySend:
{
Proxy.ReceivedMessageAsProxy(message);
} break;
}
});
t.Start();
}
