public override void processMessage(MessageArrivedEventArgs messageArgs)
{
User user;
// zaten login olmus biri tekrar login olmaya calismasin sakin
if (Game.clientUserMap.TryGetValue(messageArgs.sender, out user) == false)
{
RawMessage message = messageArgs.message;
if (message != null && message.containsField("username"))
{
string username = message.getUTF8String("username");
if (username.StartsWith("ArenaSize:"))
{
int size = int.Parse(username.Split(':')[1]);
Game.queue.maxUserCount = Math.Max(2, size);
OM_LoginResult.SendMessage(messageArgs.sender, false);
}
else
{
user = new User(messageArgs.sender, username);
Game.clientUserMap.Add(messageArgs.sender, user);
OM_LoginResult.SendMessage(messageArgs.sender, true, user);
}
}
}
}
public override void processMessage(MessageArrivedEventArgs messageArgs)
{
int typeId = messageArgs.message.getInt("skillTypeId");
int slotIndex = messageArgs.message.getInt("slotIndex");
Player player;
if (Game.clientPlayerMap.TryGetValue(messageArgs.sender, out player))
{
Type skillType = TypeIdGenerator.skillTypesByIds[typeId].GetType();
if (player.skills.Any(s => s.GetType() == skillType))
{
return;
}
Skill skill = Activator.CreateInstance(skillType, player) as Skill;
int price = skill.UnlockPrice + player.skills.Count * 2;
if (skill != null && player.SpendGold(price))
{
player.skills.Add(skill);
OM_SkillUnlocked.SendMessage(player, typeId, slotIndex);
OM_PlayerGoldInfo.SendMessage(player);
}
}
}
private void OnMessageReceived(ProximityDevice sender, ProximityMessage message)
{
var stopwatch = (Stopwatch)null;
if (Debug)
{
stopwatch = new Stopwatch();
stopwatch.Start();
}
var rawMessage = message.Data.ToArray();
NdefMessage ndefMessage;
try
{
ndefMessage = NdefMessage.FromByteArray(rawMessage);
}
catch (NdefException e)
{
var exceptionArgs = new DeviceStatusChangedEventArgs()
{
DeviceStatus = StatusEnum.DeviceArrived
};
if (Debug)
{
stopwatch.Stop();
exceptionArgs.ExecutionTime = stopwatch.Elapsed;
}
OnDeviceStatusChanged(this, exceptionArgs);
return;
}
var args = new MessageArrivedEventArgs()
{
DeviceStatus = StatusEnum.MessageReceived
};
foreach (NdefRecord record in ndefMessage)
{
if (NdefTextRecord.IsRecordType(record))
{
NdefTextRecord textRecord = new NdefTextRecord(record);
args.Message = textRecord.Text;
break;
}
}
if (Debug)
{
stopwatch.Stop();
args.ExecutionTime = stopwatch.Elapsed;
args.MethodName = "TagReader.OnMessageReceived";
}
OnDeviceStatusChanged(this, args);
OnMessageArrived(this, args);
}
public override void processMessage(MessageArrivedEventArgs messageArgs)
{
Player player = null;
if (Game.clientPlayerMap.TryGetValue(messageArgs.sender, out player))
{
player.arena.PlayerDoneLoading(player);
}
}
/// <summary>
/// Processes a message that was received from a remote client
/// </summary>
/// <param name="message">the message that was received from the remote host</param>
/// <returns>a response message that was generated as result of the received message</returns>
public ServiceOperationResponseMessage ProcessMessage(ServerOperationMessage message)
{
var msg = new MessageArrivedEventArgs
{
TargetService = message.TargetService,
Message = message.OperationPayload
};
if (!string.IsNullOrEmpty(message.HubUser))
{
msg.HubUser = JsonHelper.FromJsonStringStrongTyped <TransferIdentity>(message.HubUser).ToIdentity(serverSecurity);
}
OnMessageArrived(msg);
ServiceOperationResponseMessage ret;
if (msg.Completed)
{
if (msg.Error == null)
{
ret = new ServiceOperationResponseMessage
{
OperationId = message.OperationId,
ResponsePayload = msg.Response,
TargetService = message.TargetService,
Ok = true
};
}
else
{
ret = new ServiceOperationResponseMessage
{
OperationId = message.OperationId,
ResponsePayload = JsonHelper.ToJsonStrongTyped(msg.Error, true),
TargetService = message.TargetService,
Ok = false
};
}
}
else
{
ret = new ServiceOperationResponseMessage
{
OperationId = message.OperationId,
TargetService = message.TargetService,
ResponsePayload = JsonHelper.ToJsonStrongTyped(new SerializedException("Message was not processed!", new SerializedException[0]), true),
Ok = false
};
}
if (!string.IsNullOrEmpty(consumedService))
{
ret.ResponderFor = consumedService;
}
return(ret);
}
public override void processMessage(MessageArrivedEventArgs messageArgs)
{
Player player;
if (Game.clientPlayerMap.TryGetValue(messageArgs.sender, out player))
{
//if (player.arena.state == Arena.ArenaState.Battle || player.arena.state == Arena.ArenaState.RoundOver || player.arena.state == Arena.ArenaState.BattleOver)
player.arena.PlayerKick(player);
}
}
public override void processMessage(MessageArrivedEventArgs messageArgs)
{
User user;
// login olmamis biri join olamamali
if (Game.clientUserMap.TryGetValue(messageArgs.sender, out user))
{
OM_JoinQueueResult.SendMessage(messageArgs.sender, true);
Game.queue.AddUser(user); // bu metodun icinde kullanici var mi diye kontrol ediyoruz, varsa eklemiyoruz.
}
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void Consumer_Received(object sender, BasicDeliverEventArgs e)
{
var eventArgsModel = new MessageArrivedEventArgs(e.ConsumerTag, e.DeliveryTag, e.Exchange, e.Redelivered, e.RoutingKey, e.Body.ToArray(), Ack);
//Invoke the event
MessageArrived?.Invoke(sender, eventArgsModel);
if (mIsAutoAck)
{
Ack(e.DeliveryTag, false);
}
}
private void handleReading()
{
NetworkStream stream = client.GetStream();
while (curUser.HasOngoingChat)
{
try
{
string raw_info = Utility.ReadFromNetworkStream(stream);
string sender = raw_info.Split("|", 2)[0];
string msg = raw_info.Split("|", 2)[1];
if (sender == "SERVER")
{
handleCommands(raw_info);
}
MessageArrivedEventArgs e = new MessageArrivedEventArgs();
string historymessage = Utility.MessageFormatter(sender, msg) + "\n";
curUser.LastPrivateChatHistory = curUser.LastPrivateChatHistory + historymessage;
e.MessageSender = sender;
e.Message = msg;
OnMessageArrived(e);
}
catch (IndexOutOfRangeException ie) ///if the data is corrupted bcs of networking
{
/*ExitChat();
* EventArgs eventarg = new EventArgs();
*
* OnLostConnection(eventarg);*/
Trace.WriteLine("yeah its happening");
}
catch (Exception e)
{
Thread.Sleep(100);
if (!curUser.HasOngoingChat)
{
Trace.WriteLine("Looks like chat ended by occasion error message: " + e.Message);
}
else
{
Trace.WriteLine("Smth shit happened in private chat reading, error message: " + e.Message);
EventArgs eventarg = new EventArgs();
OnLostConnection(eventarg);
}
}
}
}
public override void processMessage(MessageArrivedEventArgs messageArgs)
{
User user;
// login olmus mu?
if (Game.clientUserMap.TryGetValue(messageArgs.sender, out user))
{
if (Game.queue.RemoveUser(user))
{
OM_LeaveQueueResult.SendMessage(messageArgs.sender, true);
}
}
}
public override void processMessage(MessageArrivedEventArgs messageArgs)
{
Player player;
if (Game.clientPlayerMap.TryGetValue(messageArgs.sender, out player))
{
if (player.state == Player.PlayerState.InGame && player.arena.state == Arena.ArenaState.Battle && player.IsAlive)
{
Vector3 walkTarget = messageArgs.message.GetVector3("walkTarget");
walkTarget.y = 0;
player.WalkRequest(walkTarget);
}
}
}
void server_messageArrivedEvent(object sender, MessageArrivedEventArgs e)
{
User user;
bool objectFound = false;
lock ( userdictionary)
{
objectFound = userdictionary.TryGetValue(e.sender, out user);
}
if (objectFound) // user bulunamadiysa muhtemelen login olmamis biridir. Login olmadan, userlar userDictionary ye eklenmezler.
{
user.addMessage(e.message);
}
}
/// <summary>
/// Processes incoming messages from the server
/// </summary>
/// <param name="sender">the sender of the event (normally the grpc connector)</param>
/// <param name="e">the event-arguments that werde constructed from the server-request</param>
private void ProcessMessage(object?sender, MessageArrivedEventArgs e)
{
var message = TestMessage <EventNotificationMessage>(Task.FromResult(e.Message)).ConfigureAwait(false).GetAwaiter().GetResult();
try
{
RaiseEvent(message.EventName, message.Arguments);
e.Response = JsonHelper.ToJsonStrongTyped(message, true);
}
catch (Exception ex)
{
e.Error = ex;
}
finally
{
e.Completed = true;
}
}
public override void processMessage(MessageArrivedEventArgs messageArgs)
{
Player player;
if (Game.clientPlayerMap.TryGetValue(messageArgs.sender, out player) && player.state == Player.PlayerState.InGame && player.arena.state == Arena.ArenaState.Battle)
{
int skillIndex = messageArgs.message.getInt("skillIndex");
if (player.skills != null && player.skills.Count > skillIndex && player.IsAlive) //dead man cant shoot
{
Skill skill = player.skills[skillIndex];
Vector3 usePosition = messageArgs.message.GetVector3("usePosition");
if (skill != null && skill.IsActivatable(usePosition))
{
skill.ActivateAndNotify(usePosition);
}
}
}
}
public override void processMessage(MessageArrivedEventArgs messageArgs)
{
Player player;
if (Game.clientPlayerMap.TryGetValue(messageArgs.sender, out player) && player.state == Player.PlayerState.AnsweringReady)
{
bool ready = messageArgs.message.getBool("isReady");
if (ready)
{
player.state = Player.PlayerState.WaitingOthersReady;
player.arena.PlayerAcceptedReady(player);
}
else
{
player.arena.PlayerRejectedReady(player);
}
}
}
/// <summary>
/// when you want to leave the chat
/// </summary>
public void ExitChat()
{
if (client == null)
{
return;
}
if (curUser.HasOngoingChat)
{
//client.Connect(PortManager.instance().Host, PortManager.instance().Matchport);
try
{
NetworkStream stream = client.GetStream();
string msg = "!LEAVE|" + curUser.Username;
byte[] buffer = Encoding.Unicode.GetBytes("KNOCKNOCK|" + msg);
stream.Write(buffer);
Trace.WriteLine(msg + " sent!");
}
catch (Exception e)
{
Trace.WriteLine("exiting with error on exitchat error msg: " + e.Message);
}
finally
{
client.Close();
curUser.HasOngoingChat = false;
MessageArrivedEventArgs e = new MessageArrivedEventArgs();
e.MessageSender = "SERVER";
e.Message = "!LEFT|" + curUser.Username;
OnMessageArrived(e);
EventArgs em = new EventArgs();
//e.ConverastionId = curUser.LastPrivateChatConversationId;
OnChatEnded(em);
}
}
}
private void OnMessageArrived(object sender, MessageArrivedEventArgs e)
{
var result = coreDispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
var stopwatch = (Stopwatch)null;
if (Debug)
{
stopwatch.Start();
}
DeviceStatus = Enum.GetName(typeof(StatusEnum), e.DeviceStatus);
Message = e.Message;
Foreground = e.Message.ToUpper();
Background = SelectBackgroundFromMessage(e.Message);
if (Debug)
{
Log += $"{e.ToString()}\n";
stopwatch.Stop();
Log += $"{{\"Display.OnMessageArrived\":{{ \"ExecutionTime\":\"{stopwatch.Elapsed.ToString()}\" }} }}\n";
}
});
}
public void OnRandomChatMessageArrived(object sender, MessageArrivedEventArgs msg)
{
string username = msg.MessageSender;
if (username != curUser.Username)
{
Console.Beep();
}
string text = msg.Message;
string displayText = Utility.MessageFormatter(username, text);
Trace.WriteLine(displayText);
this.Dispatcher.Invoke(() =>
{
Paragraph paragraph = new Paragraph();
paragraph.Inlines.Add(new Run(displayText));
if (username == curUser.Username)
{
paragraph.TextAlignment = TextAlignment.Right;
paragraph.Foreground = Brushes.Orange;
}
else
{
paragraph.TextAlignment = TextAlignment.Left;
paragraph.Foreground = Brushes.Purple;
}
this.privateChatHistory.Document.Blocks.Add(paragraph);
this.messageTextBox.Focus();
this.privateChatHistory.ScrollToEnd();
});
}
void server_messageArrivedEvent(object sender, MessageArrivedEventArgs e)
{
lock (messages)
messages.Enqueue(e.message);
}
private static void ServerOnMessageArrivedEvent(object sender, MessageArrivedEventArgs messageArrivedEventArgs)
{
arrivedMessages.Enqueue(messageArrivedEventArgs);
}
public bool HandlePrivateChatting(GENDER LookingForSex)
{
bool success = false;
try
{
client = new TcpClient(PortManager.instance().Host, PortManager.instance().Matchport);
}
catch (Exception e)
{
Trace.WriteLine("error in connection to matchmaking shit err msg: " + e.Message);
EventArgs er = new EventArgs();
OnLostConnection(er);
return(false);
}
if (!connectToPrivateChatQueue(LookingForSex))
{
Trace.WriteLine("Chatconnecting error at phase 1");
ShutDownChat();
return(false);
}
try
{
NetworkStream stream = client.GetStream();
while (true)
{
Trace.WriteLine("PrivateChat: get matchport...");
string matchinfo = Utility.ReadFromNetworkStream(stream);
int chatport = int.Parse(matchinfo);
if (!curUser.HasOngoingChatSearch)
{
client.GetStream().Close();
client.Close();
return(false);
}
Trace.WriteLine("PrivateChat: trying to verify...");
string verify = Utility.ReadFromNetworkStream(stream);
string[] verifyparams = verify.Split("|", 2);
if (verifyparams[0] == "OK")
{
curUser.LastPrivateChatHistory = "";
curUser.LastPrivateChatConversationId = verifyparams[1];
Trace.WriteLine("PrivateChat: verified! Conversationid: " + verifyparams[1]);
if (curUser.Username == curUser.LastPrivateChatConversationId.Split("|")[1])
{
curUser.LastPrivateChatUsername = verifyparams[1].Split("|")[2];
}
else
{
curUser.LastPrivateChatUsername = verifyparams[1].Split("|")[1];
}
curUser.HasOngoingChat = true;
client = new TcpClient(PortManager.instance().Host, chatport);
EventArgs e = new EventArgs();
OnChatBegins(e);
Thread t = new Thread(handleReading);
t.Start();
MessageArrivedEventArgs startMsg = new MessageArrivedEventArgs();
startMsg.MessageSender = "SERVER";
startMsg.Message = "!JOINED|" + curUser.LastPrivateChatUsername;
OnMessageArrived(startMsg);
MessageArrivedEventArgs startMsg2 = new MessageArrivedEventArgs();
startMsg2.MessageSender = "SERVER";
startMsg2.Message = "!JOINED|" + curUser.Username;
OnMessageArrived(startMsg2);
break;
}
else
{
Trace.WriteLine("Failed matchmaking attempt.");
}
}
}
catch (Exception e)
{
Trace.WriteLine("Chatconnecting error at phase 2. Error message: " + e.Message);
if (curUser.HasOngoingChatSearch)
{
EventArgs er = new EventArgs();
OnLostConnection(er);
}
ShutDownChat();
}
return(success);
}
/// <summary>
/// Raises the MessageArrived event
/// </summary>
/// <param name="e">the arguments for the arrived message</param>
protected virtual void OnMessageArrived(MessageArrivedEventArgs e)
{
MessageArrived?.Invoke(this, e);
}
/// <summary>
/// Initializes the hubconnection with the remote hub
/// </summary>
private void InitHubConnection()
{
rnd = new Random();
client = factory.CreateClient(serviceAddr, channel);
client.Broken += ClientBroken;
ServiceName = myServiceName;
if (!string.IsNullOrEmpty(ServiceName))
{
mySvc = new RegisterServiceMessage {
ServiceName = ServiceName, Ttl = 15
};
if (!string.IsNullOrEmpty(consumedService))
{
mySvc.ResponderFor = consumedService;
}
var reg = client.RegisterService(mySvc);
if (reg.Ok)
{
session = new ServiceSessionOperationMessage {
ServiceName = mySvc.ServiceName, SessionTicket = reg.SessionTicket, Ttl = mySvc.Ttl
};
if (!string.IsNullOrEmpty(consumedService))
{
session.ResponderFor = consumedService;
}
tickTimer.Change(0, TickPeriod);
serverCallbackCancel = new CancellationTokenSource();
var token = serverCallbackCancel.Token;
Task.Run(async() =>
{
var cancelR = token;
try
{
client.ServiceReady(session);
LogEnvironment.LogDebugEvent("Service is ready!", LogSeverity.Report);
while (await channel.MoveNext().ConfigureAwait(false))
{
var c = channel.Current;
LogEnvironment.LogDebugEvent(
$"TargetService: {c.TargetService}, TickBack: {c.TickBack}, Id: {c.OperationId}",
LogSeverity.Report);
if (!c.TickBack)
{
var msg = new MessageArrivedEventArgs
{
Message = c.OperationPayload,
TargetService = c.TargetService
};
if (!string.IsNullOrEmpty(c.HubUser))
{
msg.HubUser = JsonHelper.FromJsonStringStrongTyped <TransferIdentity>(c.HubUser)
.ToIdentity(customServerSecurity);
}
OnMessageArrived(msg);
ServiceOperationResponseMessage ret;
if (msg.Completed)
{
if (msg.Error == null)
{
ret = new ServiceOperationResponseMessage
{
OperationId = c.OperationId,
ResponsePayload = msg.Response,
TargetService = c.TargetService,
Ok = true
};
}
else
{
ret = new ServiceOperationResponseMessage
{
OperationId = c.OperationId,
ResponsePayload = JsonHelper.ToJsonStrongTyped(msg.Error, true),
TargetService = c.TargetService,
Ok = false
};
}
}
else
{
ret = new ServiceOperationResponseMessage
{
OperationId = c.OperationId,
TargetService = c.TargetService,
ResponsePayload = JsonHelper.ToJsonStrongTyped(
new SerializedException("Message was not processed!",
new SerializedException[0]), true),
Ok = false
};
}
if (!string.IsNullOrEmpty(consumedService))
{
ret.ResponderFor = consumedService;
}
client.CommitServiceOperation(ret);
}
else
{
LogEnvironment.LogDebugEvent("TickBack from Hub!", LogSeverity.Report);
}
}
}
catch (IOException ex)
{
LogEnvironment.LogDebugEvent(
$"Connection has gone... {ex.Message}, {ex.GetType().FullName}", LogSeverity.Warning);
}
catch (CommunicationException ex)
{
LogEnvironment.LogDebugEvent($"Connection has gone... {ex.Message}", LogSeverity.Warning);
}
catch (Exception ex)
{
LogEnvironment.LogEvent($"Unexpected Error: {ex.OutlineException()}", LogSeverity.Error);
}
finally
{
if (!disposing)
{
LostConnection();
}
}
}, token);
}
else
{
ServiceName = null;
throw new Exception($"Unable to register Service: {reg.Reason}");
}
}
}
public abstract void processMessage(MessageArrivedEventArgs messageArgs);
public void OnMessageArrivedEventArgs(MessageArrivedEventArgs i_EventArgs)
{
this.MessageArrived?.Invoke(this, i_EventArgs);
}
public void OnMessageReceived(object sender, MessageArrivedEventArgs e)
{
if (InvokeRequired)
{
Invoke(new EventHandler<MessageArrivedEventArgs>(OnMessageReceived), new object[] { sender, e });
}
else
{
if (e is NudgeArrivedEventArgs)
{
MakeVisible(sender, e);
PrintNudge(e as NudgeArrivedEventArgs);
}
else if (e is TypingArrivedEventArgs)
{
MakeVisible(sender, e);
PrintTyping(e as TypingArrivedEventArgs);
}
else if (e is TextMessageArrivedEventArgs)
{
MakeVisible(sender, e);
PrintText(e.Sender, (e as TextMessageArrivedEventArgs).TextMessage);
}
else if (e is EmoticonArrivedEventArgs)
{
MakeVisible(sender, e);
Emoticon emo = (e as EmoticonArrivedEventArgs).Emoticon;
if (emo != null)
{
MemoryStream ms = new MemoryStream();
byte[] byt = new byte[emo.OpenStream().Length];
emo.OpenStream().Seek(0, SeekOrigin.Begin);
emo.OpenStream().Read(byt, 0, byt.Length);
ms.Write(byt, 0, byt.Length);
richTextHistory.Emotions[emo.Shortcut] = new Bitmap(Image.FromStream(ms));
ms.Close();
}
while (richTextHistory.HasEmotion)
{
richTextHistory.InsertEmotion();
}
}
else if (e is WinkEventArgs)
{
MakeVisible(sender, e);
Wink wink = (e as WinkEventArgs).Wink;
if (wink != null)
{
string path = Path.Combine(Settings.SavePath, Path.GetFileNameWithoutExtension(Path.GetRandomFileName()) + ".cab");
FileStream fs = new FileStream(path, FileMode.Create);
byte[] byt = new byte[wink.OpenStream().Length];
wink.OpenStream().Seek(0, SeekOrigin.Begin);
wink.OpenStream().Read(byt, 0, byt.Length);
fs.Write(byt, 0, byt.Length);
fs.Close();
DisplaySystemMessage("WINK saved as " + path);
}
}
}
}
void MessageManager_MessageArrived(object sender, MessageArrivedEventArgs e)
{
if (InvokeRequired)
{
BeginInvoke(new EventHandler<MessageArrivedEventArgs>(MessageManager_MessageArrived), new object[] { sender, e });
}
else
{
foreach (ConversationForm cform in ConversationForms)
{
if (cform.RemoteContact.IsSibling(e.Sender))
{
cform.OnMessageReceived(sender, e);
return;
}
}
if (!(e is TypingArrivedEventArgs))
{
CreateConversationForm(e.Sender).OnMessageReceived(sender, e);
}
}
}
private void ClientInvokation(object?sender, MessageArrivedEventArgs e)
{
var msg = JsonHelper.FromJsonStringStrongTyped <object>(e.Message);
LogEnvironment.LogDebugEvent($"Message is {msg}", LogSeverity.Report);
LogEnvironment.LogDebugEvent(e.Message, LogSeverity.Report);
try
{
if (msg is AbandonExtendedProxyRequestMessage aeprm)
{
var ok = AbandonExtendedProxy(aeprm.ObjectName, aeprm.AuthenticatedUser?.ToIdentity() ?? e.HubUser);
e.Response = JsonHelper.ToJsonStrongTyped(new AbandonExtendedProxyResponseMessage {
Result = ok
}, true);
}
else if (msg is ObjectAvailabilityRequestMessage oarm)
{
var avail = CheckForAvailableProxy(oarm.UniqueName, oarm.AuthenticatedUser?.ToIdentity() ?? e.HubUser);
e.Response = JsonHelper.ToJsonStrongTyped(new ObjectAvailabilityResponseMessage
{
Message = avail.Message,
Available = avail.Available
}, true);
LogEnvironment.LogDebugEvent($"Response: {e.Response}.", LogSeverity.Report);
}
else if (msg is SetPropertyRequestMessage sprm)
{
SetProperty(sprm.TargetObject, sprm.TargetMethod, sprm.MethodArguments, sprm.Value, sprm.AuthenticatedUser?.ToIdentity() ?? e.HubUser);
e.Response = JsonHelper.ToJsonStrongTyped(new SetPropertyResponseMessage
{
Ok = true
}, true);
}
else if (msg is GetPropertyRequestMessage gprm)
{
var retVal = GetProperty(gprm.TargetObject, gprm.TargetMethod, gprm.MethodArguments, gprm.AuthenticatedUser?.ToIdentity() ?? e.HubUser);
e.Response = JsonHelper.ToJsonStrongTyped(new GetPropertyResponseMessage
{
Result = retVal,
Arguments = gprm.MethodArguments
}, true);
}
else if (msg is InvokeMethodRequestMessage imrm)
{
var result = ExecuteMethod(imrm.TargetObject, imrm.TargetMethod, imrm.MethodArguments, imrm.AuthenticatedUser?.ToIdentity() ?? e.HubUser);
e.Response = JsonHelper.ToJsonStrongTyped(new InvokeMethodResponseMessage
{
Arguments = result.Parameters,
Result = result.Result
}, true);
}
else if (msg is UnRegisterEventRequestMessage urerm)
{
var ok = UnSubscribeEvent(urerm.TargetObject, urerm.EventName, urerm.RespondChannel, urerm.AuthenticatedUser?.ToIdentity() ?? e.HubUser);
e.Response = JsonHelper.ToJsonStrongTyped(new UnRegisterEventResponseMessage
{
Ok = ok
}, true);
}
else if (msg is RegisterEventRequestMessage rerm)
{
var ok = SubscribeForEvent(rerm.TargetObject, rerm.EventName, rerm.RespondChannel, rerm.AuthenticatedUser?.ToIdentity() ?? e.HubUser);
e.Response = JsonHelper.ToJsonStrongTyped(new RegisterEventResponseMessage
{
Ok = ok
}, true);
}
else
{
throw new InvalidOperationException($"Unexpected message {msg?.GetType().FullName ?? "NULL"}!");
}
}
catch (Exception ex)
{
e.Error = ex;
}
finally
{
e.Completed = true;
}
}
void server_messageArrivedEvent(object sender, MessageArrivedEventArgs e)
{
User user;
bool objectFound = false;
lock( userdictionary)
{
objectFound = userdictionary.TryGetValue(e.sender, out user);
}
if( objectFound ) // user bulunamadiysa muhtemelen login olmamis biridir. Login olmadan, userlar userDictionary ye eklenmezler.
user.addMessage(e.message);
}
/// <summary>
/// Initializes the hubconnection with the remote hub
/// </summary>
private void InitHubConnection()
{
AppContext.SetSwitch(
"System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);
rnd = new Random();
GrpcChannelOptions options = new GrpcChannelOptions();
configurator.ConfigureChannel(options);
channel = GrpcChannel.ForAddress(serviceAddr, options);
client = new ServiceHub.ServiceHubClient(channel);
ServiceName = myServiceName;
if (!string.IsNullOrEmpty(ServiceName))
{
mySvc = new RegisterServiceMessage {
ServiceName = ServiceName, Ttl = 15
};
if (!string.IsNullOrEmpty(consumedService))
{
mySvc.ResponderFor = consumedService;
}
var reg = client.RegisterService(mySvc);
if (reg.Ok)
{
session = new ServiceSessionOperationMessage {
ServiceName = mySvc.ServiceName, SessionTicket = reg.SessionTicket, Ttl = mySvc.Ttl
};
if (!string.IsNullOrEmpty(consumedService))
{
session.ResponderFor = consumedService;
}
tickTimer.Change(0, TickPeriod);
serverCallbackCancel = new CancellationTokenSource();
var token = serverCallbackCancel.Token;
Task.Run(async() =>
{
var cancelR = token;
var en = client.ServiceReady(session, new CallOptions(cancellationToken: cancelR));
try
{
while (await en.ResponseStream.MoveNext())
{
var c = en.ResponseStream.Current;
if (!c.TickBack)
{
var msg = new MessageArrivedEventArgs
{
Message = c.OperationPayload,
TargetService = c.TargetService
};
if (!string.IsNullOrEmpty(c.HubUser))
{
msg.HubUser = JsonHelper.FromJsonStringStrongTyped <TransferIdentity>(c.HubUser).ToIdentity(customServerSecurity);
}
OnMessageArrived(msg);
ServiceOperationResponseMessage ret;
if (msg.Completed)
{
if (msg.Error == null)
{
ret = new ServiceOperationResponseMessage
{
OperationId = c.OperationId,
ResponsePayload = msg.Response,
TargetService = c.TargetService,
Ok = true
};
}
else
{
ret = new ServiceOperationResponseMessage
{
OperationId = c.OperationId,
ResponsePayload = JsonHelper.ToJsonStrongTyped(msg.Error, true),
TargetService = c.TargetService,
Ok = false
};
}
}
else
{
ret = new ServiceOperationResponseMessage
{
OperationId = c.OperationId,
TargetService = c.TargetService,
ResponsePayload = JsonHelper.ToJsonStrongTyped(new SerializedException("Message was not processed!", new SerializedException[0]), true),
Ok = false
};
}
if (!string.IsNullOrEmpty(consumedService))
{
ret.ResponderFor = consumedService;
}
client.CommitServiceOperation(ret);
}
else
{
LogEnvironment.LogDebugEvent("TickBack from Hub!", LogSeverity.Report);
}
}
}
catch (IOException ex)
{
LogEnvironment.LogDebugEvent($"Connection has gone... {ex.Message}, {ex.GetType().FullName}", LogSeverity.Warning);
if (!disposing)
{
LostConnection();
}
}
catch (RpcException ex)
{
LogEnvironment.LogDebugEvent($"Connection has gone... {ex.Message}", LogSeverity.Warning);
if (!disposing)
{
LostConnection();
}
}
}, token);
}
else
{
ServiceName = null;
throw new Exception($"Unable to register Service: {reg.Reason}");
}
}
}
void server_messageArrivedEvent(object sender, MessageArrivedEventArgs e)
{
lock (messages)
messages.Enqueue(e.message);
}
