private void OnStreamDataAborted(INetworkInterfaceConnection connection, IStreamChannel channel, ulong streamID)
{
if (streamID == _streamID)
{
WasCancelledByDestination = true;
TerminateWithNormalFailure("StreamData aborted");
}
}
private void OnStreamAborted(INetworkInterfaceConnection connection, IStreamChannel channel, ulong streamID)
{
if (connection == Connection && channel.Type == StreamChannelType.LargeDataTransfer)
{
_sessionInterface.NetworkInterface.StreamDataAborted -= OnStreamAborted;
TerminateWithNormalFailure("Stream aborted");
}
}
private void OnStreamDataStarted(INetworkInterfaceConnection connection, IStreamChannel channel, ulong streamID)
{
// if our id is unset and the connection and channel match, associate streamID
if (connection == _connection && channel.Type == StreamChannelType.LargeDataTransfer && _streamID == ulong.MaxValue)
{
_streamID = streamID;
}
}
public void StreamBytes(IStreamChannel channel, byte[] data)
{
if (data is null)
{
throw new ArgumentNullException(nameof(data));
}
Log.Info(PhotonNetworkInterface.LogChannel, $"[PhotonNetworkInterface] Outgoing stream started ({data.Length} bytes).");
BoltConnection.StreamBytes(((StreamChannel)channel).UdpChannelName, data);
}
private void OnStreamDataReceived(byte[] data, IStreamChannel streamChannel, INetworkInterfaceConnection source)
{
if (source == _connection)
{
_streamDataReceived = true;
ReceivedData = data;
if (_sessionInterface.NetworkInterface != null)
{
_sessionInterface.NetworkInterface.StreamDataReceived -= OnStreamDataReceived;
}
}
}
private void OnStreamDataProgress(INetworkInterfaceConnection connection, IStreamChannel channel, ulong streamID, float progress)
{
if (streamID == _streamID)
{
Progress = progress;
// send a message back to the uploader with the 'progress' of the large data transfer (needed because of a Bolt api limitation ...)
if (_nextProgressUpdateTime < Time.time)
{
_nextProgressUpdateTime = Time.time + PROGRESS_UPDATE_INTERVAL;
_sessionInterface.SendNetMessage(new NetMessageViaStreamUpdate()
{
Progress = progress
}, connection);
}
}
}
public void Event_StreamDataProgress(BoltConnection connection, UdpChannelName channel, ulong streamID, float progress)
{
INetworkInterfaceConnection interfaceConnection = FindInterfaceConnection(connection);
if (interfaceConnection == null)
{
Log.Error($"[PhotonNetworkInterface] StreamDataProgress from unknown connection: {connection}.");
return;
}
IStreamChannel streamChannel = FindStreamChannel(channel);
if (streamChannel == null)
{
Log.Error($"[PhotonNetworkInterface] StreamDataProgress from an unknown channel '{channel}'.");
return;
}
StreamDataProgress?.Invoke(interfaceConnection, streamChannel, streamID, progress);
}
public void Event_StreamDataAborted(BoltConnection connection, UdpChannelName channel, ulong streamID)
{
INetworkInterfaceConnection interfaceConnection = FindInterfaceConnection(connection);
if (interfaceConnection == null)
{
Log.Info($"[PhotonNetworkInterface] StreamDataAborted from unknown connection: {connection}.");
}
IStreamChannel streamChannel = FindStreamChannel(channel);
if (streamChannel == null)
{
Log.Error($"[PhotonNetworkInterface] StreamDataAborted from an unknown channel '{channel}'.");
return;
}
Log.Info(LogChannel, $"[PhotonNetworkInterface] Incoming stream aborted: (streamID){streamID}");
StreamDataAborted?.Invoke(interfaceConnection, streamChannel, streamID);
}
public void Event_StreamDataReceived(BoltConnection connection, UdpStreamData streamData)
{
INetworkInterfaceConnection interfaceConnection = FindInterfaceConnection(connection);
if (interfaceConnection == null)
{
Log.Error($"[PhotonNetworkInterface] Received stream data from an unknown connection: {connection}.");
return;
}
IStreamChannel streamChannel = FindStreamChannel(streamData.Channel);
if (streamChannel == null)
{
Log.Error($"[PhotonNetworkInterface] Received stream data from an unknown channel '{streamData.Channel}'.");
return;
}
Log.Info(LogChannel, "[PhotonNetworkInterface] Incoming stream data received: (length)" + streamData.Data.Length);
StreamDataReceived?.Invoke(streamData.Data, streamChannel, interfaceConnection);
}
public void Run()
{
router.Message += OnMessage;
channel = router.openChannel(CHANNELNAME, (TextReader)Console.In);
Console.Out.Write(Constants.SHELL_PROMPT);
}
public AmqpChannelListener(IStreamChannel channel, ByteBuffer buffer)
: base(channel, buffer)
{
}
public BinaryMessageChannel(IStreamChannel transportChannel, ConnectionSettings settings)
: base(settings)
{
}
public void Run()
{
router.Message += OnMessage;
channel = router.openChannel(CHANNELNAME, (TextReader) Console.In);
Console.Out.Write(Constants.SHELL_PROMPT);
}
