public void Accept()
{
var am = new AcceptMessage(AppModel.Instance.LocalDevice);
if (string.IsNullOrEmpty(SessionCode))
{
SessionCode = StringHelper.NewRandomGUID();
}
am.SessionCode = SessionCode;
if (ChannelCode != null)
{
Crypto = Env.Instance.SecurityManager.CreateCrypto(ChannelCode);
am.ChallengeResponse = Crypto.Encrypt(ChallengeRequest);
am.SendCompleted += _ =>
{
State = DeviceState.WaitSecureInitiatorConfirm;
};
}
else
{
am.SendCompleted += sendable => State = DeviceState.Connected;
//不要直接调用Post,因为那个会 检查是否已经连接，没连接，会调用Connect.
State = DeviceState.Connected;
}
channelWrapper.Post(am);
}
private void Handle(AcceptMessage m)
{
if (_isStopped)
{
return;
}
if (_initiator.CheckCreateChannel != null)
{
if (_initiator.CheckCreateChannel(m.Socket.RemoteEndPoint, m.Socket) == false)
{
m.Socket.Close();
return;
}
}
if (_initiator.TokenRequired)
{
Context.ActorOf(Props.Create(() => new TokenChecker(_initiator, this, m.Socket)));
}
else
{
var channel = Context.ActorOf(Props.Create(() => new TcpChannel(_initiator, m.Socket, null)));
if (channel == null)
{
_logger?.TraceFormat("Deny a connection. (EndPoint={0})", m.Socket.RemoteEndPoint);
return;
}
_logger?.TraceFormat("Accept a connection. (EndPoint={0})", m.Socket.RemoteEndPoint);
Context.Watch(channel);
_channelSet.Add(channel);
}
}
private void Handle(AcceptMessage m)
{
if (_isStopped)
{
return;
}
if (_initiator.CheckCreateChannel != null)
{
if (_initiator.CheckCreateChannel(m.SenderEndPoint, m.SenderConnection) == false)
{
m.SenderConnection.Disconnect("Deny new connection");
return;
}
}
IActorRef channel;
if (_initiator.TokenRequired)
{
WaitingItem item;
lock (_waitingMap)
{
if (_waitingMap.TryGetValue(m.Token, out item) == false)
{
m.SenderConnection.Disconnect("Token not found");
return;
}
_waitingMap.Remove(m.Token);
}
channel = Context.ActorOf(Props.Create(() => new UdpChannel(_initiator, m.SenderConnection, item.Tag, item.BindingActor)));
}
else
{
channel = Context.ActorOf(Props.Create(() => new UdpChannel(_initiator, m.SenderConnection, null, null)));
}
if (channel == null)
{
m.SenderConnection.Deny("Server Deny");
_logger?.ErrorFormat("Deny a connection. (EndPoint={0})", m.SenderEndPoint);
return;
}
if (_channelMap.TryAdd(m.SenderConnection, channel) == false)
{
_logger?.ErrorFormat("Failed in adding new connection. (EndPoint={0})", m.SenderEndPoint);
m.SenderConnection.Deny();
channel.Tell(PoisonPill.Instance);
return;
}
_logger?.TraceFormat("Accept a connection. (EndPoint={0})", m.SenderEndPoint);
Context.Watch(channel);
_channelSet.Add(channel);
}
public void Accept()
{
if (!channel.IsInitiative && _state == ConnectionState.Connecting)
{
AcceptMessage msg = new AcceptMessage();
msg.TransferCompleted.Observers += (sendable) => State = ConnectionState.Connected;
Post(msg);
}
}
//Метод SendAccept отправляет сообщение о том,
//что мы прочли некоторое сообщение, отправленое одним из собеседников
static void SendAccept(Guid acceptedMessageId, IPEndPoint sender)
{
//Формируем сообщение, хранящее кроме типа только идентификатор прочитанного сообщения
var accept = new AcceptMessage
{
ReceivedMessageId = acceptedMessageId
};
//Конвертируем данные в json строку
var jsonString = JsonConvert.SerializeObject(accept);
//Конвертируем строку в массив байт
var data = Encoding.UTF8.GetBytes(jsonString);
//Отправляем эти байты тому, от кого пришло данное
client.Send(data, data.Length, sender);
}
public void Accept()
{
var am = new AcceptMessage(AppModel.Instance.LocalDevice);
if (string.IsNullOrEmpty(SessionCode))
{
SessionCode = StringHelper.NewRandomGUID();
}
am.SessionCode = SessionCode;
am.SendCompleted += sendable => State = DeviceState.Connected;
//不要直接调用Post,因为那个会 检查是否已经连接，没连接，会调用Connect.
channelWrapper.Post(am);
}
public void Accept()
{
var am = new AcceptMessage(SuperDriveCore.LocalDevice);
if (string.IsNullOrEmpty(SessionCode))
{
SessionCode = StringHelper.NewRandomGUID();
}
am.SessionCode = SessionCode;
am.SendCompleted += sendable =>
{
State = DeviceState.Connected;
};
//Env.Logger.Log($"Send accept message to device{this}");
SendMessage(am);
}
void OnAccept(AyameSignaling ayameSignaling)
{
AcceptMessage acceptMessage = ayameSignaling.m_acceptMessage;
bool shouldSendOffer = acceptMessage.isExistClient;
var configuration = GetSelectedSdpSemantics();
this.iceServers = configuration.iceServers;
m_conf.iceServers = this.iceServers;
// wait Offer
if (!shouldSendOffer)
{
return;
}
// TODO: Send Offer
}
public async Task <AcceptMessage> saveOrder(string jsonMessage)
{
var jsonObject = JsonConvert.DeserializeObject <PetitionElements>(jsonMessage);
Autentication autorizaction = new Autentication(_hl7Context);
AcceptMessage resultMessage = new AcceptMessage();
if (autorizaction.validateToken(jsonObject.Token))
{
RequestParser requestParser = new RequestParser();
resultMessage.Estado = true;
resultMessage.Mensaje = "OK";
var messageData = requestParser.decodeOrderData(jsonObject);
var transactionSaved = saveTransaction(messageData, jsonMessage).Result;
if (transactionSaved)
{
List <His2lis> ordersList = BuildOrderRequest(messageData);
foreach (His2lis itemData in ordersList)
{
_context.His2lis.Add(itemData);
_context.SaveChanges();
}
_context.His2lis.AddRange(ordersList);
}
else
{
resultMessage.Estado = false;
resultMessage.Mensaje = "Error";
}
}
else
{
resultMessage.Estado = false;
resultMessage.Mensaje = "Token invalido";
}
return(resultMessage);
}
private void Handle(AcceptMessage m)
{
if (_isStopped)
return;
if (_initiator.CheckCreateChannel != null)
{
if (_initiator.CheckCreateChannel(m.Socket.RemoteEndPoint, m.Socket) == false)
{
m.Socket.Close();
return;
}
}
if (_initiator.TokenRequired)
{
Context.ActorOf(Props.Create(() => new TokenChecker(_initiator, this, m.Socket)));
}
else
{
var channel = Context.ActorOf(Props.Create(() => new TcpChannel(_initiator, m.Socket, null)));
if (channel == null)
{
_logger?.TraceFormat("Deny a connection. (EndPoint={0})", m.Socket.RemoteEndPoint);
return;
}
_logger?.TraceFormat("Accept a connection. (EndPoint={0})", m.Socket.RemoteEndPoint);
Context.Watch(channel);
_channelSet.Add(channel);
}
}
public MessengerPresenter(IPresentationCore context, AcceptMessage acceptMessage)
{
this.context = context ?? throw new ArgumentNullException(nameof(context));
this.acceptMessage = acceptMessage ?? throw new ArgumentNullException(nameof(acceptMessage));
}
private void WSProcessMessage(object sender, MessageEventArgs e)
{
var content = Encoding.UTF8.GetString(e.RawData);
Debug.Log($"Signaling: Receiving message: {content}");
try
{
var message = JsonUtility.FromJson <Message>(content);
string type = message.type;
switch (type)
{
case "accept":
{
AcceptMessage acceptMessage = JsonUtility.FromJson <AcceptMessage>(content);
this.m_acceptMessage = acceptMessage;
this.OnAccept?.Invoke(this);
break;
}
case "offer":
{
OfferMessage offerMessage = JsonUtility.FromJson <OfferMessage>(content);
DescData descData = new DescData();
descData.connectionId = this.m_acceptMessage.connectionId;
descData.sdp = offerMessage.sdp;
this.OnOffer?.Invoke(this, descData);
break;
}
case "answer":
{
AnswerMessage answerMessage = JsonUtility.FromJson <AnswerMessage>(content);
DescData descData = new DescData();
descData.connectionId = this.m_acceptMessage.connectionId;
descData.sdp = answerMessage.sdp;
this.OnAnswer?.Invoke(this, descData);
break;
}
case "candidate":
{
CandidateMessage candidateMessage = JsonUtility.FromJson <CandidateMessage>(content);
CandidateData candidateData = new CandidateData();
candidateData.connectionId = this.m_acceptMessage.connectionId;
candidateData.candidate = candidateMessage.ice.candidate;
candidateData.sdpMLineIndex = candidateMessage.ice.sdpMLineIndex;
candidateData.sdpMid = candidateMessage.ice.sdpMid;
this.OnIceCandidate?.Invoke(this, candidateData);
break;
}
case "ping":
{
PongMessage pongMessage = new PongMessage();
this.WSSend(JsonUtility.ToJson(pongMessage));
break;
}
case "bye":
{
// TODO:
break;
}
default:
{
Debug.LogError("Signaling: Received message from unknown peer");
break;
}
}
}
catch (Exception ex)
{
Debug.LogError("Signaling: Failed to parse message: " + ex);
}
}
private void Handle(AcceptMessage m)
{
if (_isStopped)
return;
if (_initiator.CheckCreateChannel != null)
{
if (_initiator.CheckCreateChannel(m.SenderEndPoint, m.SenderConnection) == false)
{
m.SenderConnection.Disconnect("Deny new connection");
return;
}
}
IActorRef channel;
if (_initiator.TokenRequired)
{
WaitingItem item;
lock (_waitingMap)
{
if (_waitingMap.TryGetValue(m.Token, out item) == false)
{
m.SenderConnection.Disconnect("Token not found");
return;
}
_waitingMap.Remove(m.Token);
}
channel = Context.ActorOf(Props.Create(() => new UdpChannel(_initiator, m.SenderConnection, item.Tag, item.BindingActor)));
}
else
{
channel = Context.ActorOf(Props.Create(() => new UdpChannel(_initiator, m.SenderConnection, null, null)));
}
if (channel == null)
{
m.SenderConnection.Deny("Server Deny");
_logger?.ErrorFormat("Deny a connection. (EndPoint={0})", m.SenderEndPoint);
return;
}
if (_channelMap.TryAdd(m.SenderConnection, channel) == false)
{
_logger?.ErrorFormat("Failed in adding new connection. (EndPoint={0})", m.SenderEndPoint);
m.SenderConnection.Deny();
channel.Tell(PoisonPill.Instance);
return;
}
_logger?.TraceFormat("Accept a connection. (EndPoint={0})", m.SenderEndPoint);
Context.Watch(channel);
_channelSet.Add(channel);
}
private void OnReceivedAcceptMessage(AcceptMessage message)
{
Console.WriteLine($"move {_model.Id} accepted.");
_stationCoordinator.Tell(new StationCoordinatorActor.TransferAcceptedMessage(_model));
}
