private static void FireAndForget(GenericRequestor proxy, GenericRecord genericRecord)
{
var request = new GenericRecord(MailResponder.Protocol.Messages["fireandforget"].Request);
request.Add("message", genericRecord);
proxy.Request("fireandforget", request);
}
public void Init()
{
mailResponder = new MailResponder();
server = new SocketServer("localhost", 0, mailResponder);
server.Start();
transceiver = new SocketTransceiver("localhost", server.Port);
proxy = new GenericRequestor(transceiver, MailResponder.Protocol);
}
public void TestMultipleConnectionsCount()
{
Reset();
var transceiver2 = new SocketTransceiver("localhost", server.Port);
var proxy2 = new GenericRequestor(transceiver2, MailResponder.Protocol);
FireAndForget(proxy, CreateMessage());
FireAndForget(proxy2, CreateMessage());
transceiver2.Disconnect();
}
//[TestInitialize]
public void Init()
{
mailResponder = new MailResponder();
server = new HttpListenerServer(new string[] { URL }, mailResponder);
server.Start();
HttpWebRequest requestTemplate = (HttpWebRequest)HttpWebRequest.Create(URL);
requestTemplate.Timeout = 6000;
requestTemplate.Proxy = null;
transceiver = new HttpTransceiver(requestTemplate);
proxy = new GenericRequestor(transceiver, MailResponder.Protocol);
}
public void TestSingleRpc()
{
Transceiver t = new LocalTransceiver(new TestResponder(protocol));
var p = new GenericRecord(protocol.Messages["m"].Request);
p.Add("x", "hello");
var r = new GenericRequestor(t, protocol);
for (int x = 0; x < 5; x++)
{
object request = r.Request("m", p);
Assert.AreEqual("there", request);
}
}
// AVRO-625 [Test]
// Currently, SocketTransceiver does not permit out-of-order requests on a stateful connection.
public void Test()
{
var waitLatch = new CountdownLatch(1);
var simpleResponder = new SimpleResponder(waitLatch);
server = new SocketServer("localhost", 0, simpleResponder);
server.Start();
int port = server.Port;
transceiver = new SocketTransceiver("localhost", port);
proxy = new GenericRequestor(transceiver, SimpleResponder.Protocol);
// Step 1:
proxy.GetRemote(); // force handshake
new Thread(x =>
{
// Step 2a:
waitLatch.Wait();
var ack = new GenericRecord(SimpleResponder.Protocol.Messages["ack"].Request);
// Step 2b:
proxy.Request("ack", ack);
}).Start();
/*
* 3. Execute the Client.hello("wait") RPC, which will block until the
* Client.ack() call has completed in the background thread.
*/
var request = new GenericRecord(SimpleResponder.Protocol.Messages["hello"].Request);
request.Add("greeting", "wait");
var response = (string)proxy.Request("hello", request);
// 4. If control reaches here, both RPCs have executed concurrently
Assert.AreEqual("wait", response);
}
private async Task <GenericContext> Request(GenericContext rpcContext, CancellationToken token)
{
using (var requestData = new FrameStream())
using (var encoder = new BinaryEncoder(requestData))
{
if (DoHandshake())
{
if (rpcContext.HandshakeRequest == null)
{
rpcContext.HandshakeRequest = NewHandshakeRequest((MD5)Protocol.MD5, (MD5)RemoteProtocol.MD5);
}
HANDSHAKE_REQUEST_WRITER.Write(encoder, rpcContext.HandshakeRequest);
}
META_WRITER.Write(encoder, EMPTY_META);
encoder.WriteString(rpcContext.MessageName);
_protocol.WriteRequest(encoder, rpcContext.MessageName, rpcContext.RequestParameters);
encoder.WriteBytes(END_OF_FRAME);
requestData.Seek(0, SeekOrigin.Begin);
using (var responseData = await _tranceiver.RequestAsync(rpcContext.MessageName, requestData, token))
using (var decode = new BinaryDecoder(responseData))
{
responseData.Seek(0, SeekOrigin.Begin);
if (DoHandshake())
{
rpcContext.HandshakeResponse = HANDSHAKE_RESPONSE_READER.Read(decode);
_handshakePending = rpcContext.HandshakeResponse.match == HandshakeMatch.NONE;
var remoteProtocol = default(AvroProtocol);
if (rpcContext.HandshakeResponse.match == HandshakeMatch.CLIENT || rpcContext.HandshakeResponse.match == HandshakeMatch.NONE)
{
remoteProtocol = AvroParser.ReadProtocol(rpcContext.HandshakeResponse.serverProtocol);
_protocol = new GenericRequestor(Protocol, remoteProtocol);
}
if (rpcContext.HandshakeResponse.match == HandshakeMatch.NONE)
{
rpcContext.HandshakeRequest.serverHash = (MD5)remoteProtocol.MD5;
rpcContext.HandshakeRequest.clientProtocol = Protocol.ToAvroCanonical();
_protocol = new GenericRequestor(Protocol, remoteProtocol);
rpcContext = await Request(rpcContext, token);
}
}
rpcContext.Metadata = META_READER.Read(decode);
rpcContext.IsError = decode.ReadBoolean();
if (rpcContext.IsError)
{
rpcContext.Error = _protocol.ReadError <object>(decode, rpcContext.MessageName);
}
else
{
rpcContext.Response = _protocol.ReadResponse <object>(decode, rpcContext.MessageName);
}
return(rpcContext);
}
}
}
public GenericClient(AvroProtocol protocol, ITranceiver tranceiver)
: base(protocol, tranceiver)
{
RemoteProtocol = protocol;
_protocol = new GenericRequestor(Protocol, RemoteProtocol);
}
