private void OnReceiveResource(TransportConnection connection, ref DataBufferReader reader)
{
var count = reader.ReadValue <int>();
for (var i = 0; i != count; i++)
{
var id = reader.ReadValue <int>();
var type = (EAudioRegisterResourceType)reader.ReadValue <int>();
switch (type)
{
case EAudioRegisterResourceType.Bytes:
{
var data = new byte[reader.ReadValue <int>()];
reader.ReadDataSafe(data.AsSpan());
resourceManager.Register(connection, id, data);
break;
}
default:
throw new ArgumentOutOfRangeException();
}
}
}
public void Bind(TransportConnection connection)
{
IModel channel = null;
try
{
channel = connection.Connection.CreateModel();
BindQueue(channel);
PurgeIfRequested(channel);
channel.BasicQos(0, _address.PrefetchCount, false);
var consumer = new QueueingBasicConsumer(channel);
channel.BasicConsume(_address.Name, false, _consumerTag, consumer);
lock (_lock)
{
_channel = channel;
_consumer = consumer;
}
}
catch (Exception ex)
{
channel.Cleanup(500, ex.Message);
throw new InvalidConnectionException(_address.Uri, "Invalid connection to host", ex);
}
}
public void AddConnection(long id, TransportConnection connection)
{
if (!_connectionReferences.TryAdd(id, new ConnectionReference(connection)))
{
throw new ArgumentException(nameof(id));
}
}
public void Bind(TransportConnection connection)
{
lock (_lock)
{
IModel channel = null;
try
{
channel = connection.Connection.CreateModel();
DeclareAndBindQueue(connection, channel);
BindEvents(channel);
if (_publisherConfirmSettings.UsePublisherConfirms)
{
channel.ConfirmSelect();
}
_channel = channel;
}
catch (Exception ex)
{
if (channel != null)
{
channel.Cleanup(500, ex.Message);
}
throw new InvalidConnectionException(_address.Uri, "Invalid connection to host", ex);
}
}
}
public void Unbind(TransportConnection connection)
{
lock (_lock)
{
try
{
if (_channel != null)
{
if (_publisherConfirmSettings.UsePublisherConfirms)
{
WaitForPendingConfirms();
}
UnbindEvents(_channel);
_channel.Cleanup(200, "Producer Unbind");
}
}
finally
{
if (_channel != null)
{
_channel.Dispose();
}
_channel = null;
FailPendingConfirms();
}
}
}
// OnConnection는 Kestrel의 SocketTransPort.cs의 RunAcceptLoopAsync에서 호출하고 있다.
public Task OnConnection(TransportConnection connection)
{
//TODO 옵션에서 리드, 라이트 버퍼 크기 얻어와야 된다
var inputOptions = GetInputPipeOptions(connection.InputWriterScheduler, 0, connection.MemoryPool, connection.InputWriterScheduler);
var outputOptions = GetOutputPipeOptions(connection.OutputReaderScheduler, 0, connection.MemoryPool, connection.OutputReaderScheduler);
var pair = DuplexPipe.CreateConnectionPair(inputOptions, outputOptions);
// TODO 숫자 기반 uid로 바꾼다
connection.ConnectionId = CorrelationIdGenerator.GetNextId();
connection.Transport = pair.Transport;
// This *must* be set before returning from OnConnection
connection.Application = pair.Application;
//var channel = new TcpPipeChannel(connection, PipelineFilter);
//channel.OnPackageReceived = ConnectionDispatcher.OnPackageReceived;
//var session = new AppSession(channel);
var session = NewClientAccepted(connection);
Interlocked.Increment(ref _sessionCount);
try
{
return(session.Channel.ProcessRequest());
}
finally
{
Interlocked.Decrement(ref _sessionCount); //TODO 에러인 듯. catch 절에서 호출해야 된다
}
}
public void OnRead(TransportConnection connection, ref DataBufferReader reader)
{
var ev = reader.ReadValue <SControllerEvent>();
var entity = playerManager.Get(connection, ev.Player);
switch (ev.State)
{
case SControllerEvent.EState.Paused:
break;
case SControllerEvent.EState.Stop:
entity.Set(new StopAudioRequest());
break;
case SControllerEvent.EState.Play:
var resource = resourceManager.GetWav(connection, ev.ResourceId);
entity.Set(resource);
entity.Set(new PlayAudioRequest());
break;
default:
throw new ArgumentOutOfRangeException();
}
entity.Set <StandardAudioPlayerComponent>();
if (ev.Delay > TimeSpan.Zero)
{
entity.Set(new AudioDelayComponent(worldTime.Total + ev.Delay - worldTime.Delta));
}
}
public void OnConnectionCreatesLogScopeWithConnectionId()
{
var serviceContext = new TestServiceContext();
var tcs = new TaskCompletionSource <object>();
var dispatcher = new ConnectionDispatcher(serviceContext, _ => tcs.Task);
var connection = new TransportConnection();
dispatcher.OnConnection(connection);
// The scope should be created
var scopeObjects = ((TestKestrelTrace)serviceContext.Log)
.Logger
.Scopes
.OfType <IReadOnlyList <KeyValuePair <string, object> > >()
.ToList();
Assert.Single(scopeObjects);
var pairs = scopeObjects[0].ToDictionary(p => p.Key, p => p.Value);
Assert.True(pairs.ContainsKey("ConnectionId"));
Assert.Equal(connection.ConnectionId, pairs["ConnectionId"]);
tcs.TrySetResult(null);
// Verify the scope was disposed after request processing completed
Assert.True(((TestKestrelTrace)serviceContext.Log).Logger.Scopes.IsEmpty);
}
public void ConnectionStop(TransportConnection connection)
{
if (IsEnabled())
{
ConnectionStop(connection.ConnectionId);
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: protected void reconnect() throws Exception
protected internal virtual void Reconnect()
{
if (Connection != null)
{
Connection.disconnect();
}
Connection = NewConnection();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Before public void setup() throws Exception
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
public virtual void Setup()
{
InstallSleepProcedure(_server.graphDatabaseService());
_address = _server.lookupDefaultConnector();
_connection = new SocketConnection();
_util = new TransportTestUtil(new Neo4jPackV1());
}
public void OnConnection(TransportConnection connection)
{
Input = new Pipe(InputOptions(connection.MemoryPool));
Output = new Pipe(OutputOptions(connection.MemoryPool));
connection.Transport = new DuplexPipe(Input.Reader, Output.Writer);
connection.Application = new DuplexPipe(Output.Reader, Input.Writer);
}
public void Unbind(TransportConnection connection)
{
lock (_lock)
{
_channel.Cleanup(200, "Publisher Unbind");
_channel = null;
}
}
/// <summary>
/// Closes the connection.
/// </summary>
public void Disconnect()
{
TransportConnection.Close();
if (Closed != null)
{
Closed(this, new EventArgs());
}
}
public void Bind(TransportConnection connection)
{
lock (_lock)
{
_channel = connection.Connection.CreateModel();
RebindExchanges(_channel);
}
}
public void CheckInvalidMap()
{
// Arrange
var transportConnection = new TransportConnection();
// Act
var mappedType = transportConnection.Map <TransportConnection, TransportStation>();
// Assert not needed, because there's an expected exception
}
public void Unbind(TransportConnection connection)
{
lock (_lock)
{
_consumer = null;
_channel.Cleanup(200, "Unbind Consumer");
_channel = null;
}
}
public Task OnConnection(TransportConnection connection)
{
Input = new Pipe(InputOptions(connection.MemoryPool));
Output = new Pipe(OutputOptions(connection.MemoryPool));
connection.Transport = new DuplexPipe(Input.Reader, Output.Writer);
connection.Application = new DuplexPipe(Output.Reader, Input.Writer);
return(Task.CompletedTask);
}
void DeclareAndBindQueue(TransportConnection connection, IModel channel)
{
if (_bindToQueue)
{
connection.DeclareExchange(channel, _address.Name, _address.Durable, _address.AutoDelete);
connection.BindQueue(channel, _address.Name, _address.Durable, _address.Exclusive, _address.AutoDelete,
_address.QueueArguments());
}
}
public void Send(TransportConnection connection, int resource, ref Wav wav)
{
using var writer = new DataBufferWriter(0);
writer.WriteInt((int)EAudioSendType.SendReplyResourceData);
writer.WriteInt(resource);
writer.WriteValue((double)wav.getLength());
foreach (var(_, feature) in Features)
{
feature.Driver.Send(default, connection, writer.Span);
public void ConnectionStart(TransportConnection connection)
{
// avoid allocating strings unless this event source is enabled
if (IsEnabled())
{
ConnectionStart(
connection.ConnectionId,
connection.LocalAddress != null ? new IPEndPoint(connection.LocalAddress, connection.LocalPort).ToString() : null,
connection.RemoteAddress != null ? new IPEndPoint(connection.RemoteAddress, connection.RemotePort).ToString() : null);
}
}
public override void GetConnections(Span <TransportConnection> span)
{
var i = 0;
foreach (var(id, con) in m_Connections)
{
span[i++] = new TransportConnection {
Id = con.Id, Version = (uint)m_ConnectionVersions[con.Id]
};
}
}
public TelnetConnection(MessageService messageService, TransportConnection connection,
CancellationTokenSource networkServiceTokenSource)
{
_messageService = messageService;
_connection = connection;
var internalTokenSource = new CancellationTokenSource();
_linkedTokenSource =
CancellationTokenSource.CreateLinkedTokenSource(networkServiceTokenSource.Token,
internalTokenSource.Token);
}
public void ConnectionStart(TransportConnection connection)
{
// avoid allocating strings unless this event source is enabled
if (IsEnabled())
{
ConnectionStart(
connection.ConnectionId,
connection.LocalEndPoint?.ToString(),
connection.RemoteEndPoint?.ToString());
}
}
public override TransportConnection.State GetConnectionState(TransportConnection con)
{
lock (m_QueuedConnections)
lock (m_Connections)
{
if (m_QueuedConnections.Contains(con.Id))
{
return(TransportConnection.State.PendingApproval);
}
return(m_Connections.ContainsKey(con.Id) ? TransportConnection.State.Connected : TransportConnection.State.Disconnected);
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private void enterStreaming(org.neo4j.bolt.v1.transport.socket.client.TransportConnection connection, int sleepSeconds) throws Exception
private void EnterStreaming(TransportConnection connection, int sleepSeconds)
{
ConnectAndPerformBoltHandshake(connection);
connection.Send(Util.chunk(new InitMessage("TestClient/1.1", emptyMap())));
assertThat(connection, Util.eventuallyReceives(msgSuccess()));
SECONDS.sleep(sleepSeconds); // sleep a bit to allow worker thread return back to the pool
connection.Send(Util.chunk(new RunMessage("UNWIND RANGE (1, 100) AS x RETURN x")));
assertThat(connection, Util.eventuallyReceives(msgSuccess()));
}
private async Task ReadAndRespond(TransportConnection connection)
{
while (true)
{
var result = await connection.Application.Input.ReadAsync();
Console.WriteLine("Got actual useful data and it is ---------------------------------");
Console.WriteLine(Encoding.UTF8.GetString(result.Buffer.First.ToArray()));
connection.Application.Input.AdvanceTo(result.Buffer.End);
}
//Need to read until we find a End of request and then write back the correct response
}
private void OnReceivePlayer(TransportConnection connection, ref DataBufferReader reader)
{
var count = reader.ReadValue <int>();
for (var i = 0; i != count; i++)
{
var id = reader.ReadValue <int>();
var type = reader.ReadString();
playerManager.Register(connection, id, type);
}
}
private void Close(TransportConnection connection)
{
if (connection != null)
{
try
{
connection.Disconnect();
}
catch (IOException)
{
}
}
}
public Task OnConnection(TransportConnection connection)
{
var session = new AppSession <TPackageInfo>(connection, new TPipelineFilter());
Interlocked.Increment(ref _sessionCount);
try
{
return(session.ProcessRequest());
}
finally
{
Interlocked.Decrement(ref _sessionCount);
}
}
