async Task NonExistantHCEntityTest()
{
HybridConnectionListener listener = null;
try
{
TestUtility.Log("Setting ConnectionStringBuilder.EntityPath to a new GUID");
var fakeEndpointConnectionStringBuilder = new RelayConnectionStringBuilder(this.ConnectionString)
{
EntityPath = Guid.NewGuid().ToString()
};
var fakeEndpointConnectionString = fakeEndpointConnectionStringBuilder.ToString();
listener = new HybridConnectionListener(fakeEndpointConnectionString);
var client = new HybridConnectionClient(fakeEndpointConnectionString);
#if NET451
await Assert.ThrowsAsync <EndpointNotFoundException>(() => listener.OpenAsync());
await Assert.ThrowsAsync <EndpointNotFoundException>(() => client.CreateConnectionAsync());
#else
await Assert.ThrowsAsync <RelayException>(() => listener.OpenAsync());
await Assert.ThrowsAsync <RelayException>(() => client.CreateConnectionAsync());
#endif
}
finally
{
await this.SafeCloseAsync(listener);
}
}
private static async Task RunAsync()
{
var cts = new CancellationTokenSource();
var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(KeyName, Key);
var listener = new HybridConnectionListener(new Uri(string.Format("sb://{0}/{1}", RelayNamespace, ConnectionName)), tokenProvider);
listener.Connecting += (o, e) => { Console.WriteLine("Connecting ..."); };
listener.Offline += (o, e) => { Console.WriteLine("Offine"); };
listener.Online += (o, e) => { Console.WriteLine("Onine"); };
await listener.OpenAsync(cts.Token);
Console.WriteLine("Server Listening ...");
cts.Token.Register(() => listener.CloseAsync(CancellationToken.None));
new Task(() => Console.In.ReadLineAsync().ContinueWith((s) => { cts.Cancel(); })).Start();
while (true)
{
var relayConnection = await listener.AcceptConnectionAsync();
if (relayConnection == null)
{
break;
}
ProcessMessagesOnConnection(relayConnection, cts);
}
await listener.CloseAsync(cts.Token);
}
private static async Task RunAsync()
{
var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(KeyName, Key);
var listener = new HybridConnectionListener(new Uri(string.Format("sb://{0}/{1}", RelayNamespace, ConnectionName)), tokenProvider);
// Subscribe to the status events.
listener.Connecting += (o, e) => { Console.WriteLine("Connecting"); };
listener.Offline += (o, e) => { Console.WriteLine("Offline"); };
listener.Online += (o, e) => { Console.WriteLine("Online"); };
// Provide an HTTP request handler
listener.RequestHandler = ProcessRelayedHttpRequest;
// Opening the listener establishes the control channel to
// the Azure Relay service. The control channel is continuously
// maintained, and is reestablished when connectivity is disrupted.
await listener.OpenAsync();
Console.WriteLine("Server listening");
// Start a new thread that will continuously read the console.
await Console.In.ReadLineAsync();
// Close the listener after you exit the processing loop.
await listener.CloseAsync();
}
async Task ListenerShutdownWithPendingAcceptsTest(EndpointTestType endpointTestType)
{
HybridConnectionListener listener = null;
try
{
listener = GetHybridConnectionListener(endpointTestType);
var client = GetHybridConnectionClient(endpointTestType);
TestUtility.Log($"Opening {listener}");
await listener.OpenAsync(TimeSpan.FromSeconds(20));
var acceptTasks = new List <Task <HybridConnectionStream> >(600);
TestUtility.Log($"Calling listener.AcceptConnectionAsync() {acceptTasks.Capacity} times");
for (int i = 0; i < acceptTasks.Capacity; i++)
{
acceptTasks.Add(listener.AcceptConnectionAsync());
Assert.False(acceptTasks[i].IsCompleted);
}
TestUtility.Log($"Closing {listener}");
await listener.CloseAsync(TimeSpan.FromSeconds(10));
listener = null;
for (int i = 0; i < acceptTasks.Count; i++)
{
Assert.True(acceptTasks[i].Wait(TimeSpan.FromSeconds(5)));
Assert.Null(acceptTasks[i].Result);
}
}
finally
{
await this.SafeCloseAsync(listener);
}
}
private static async Task RunAsync()
{
var cts = new CancellationTokenSource();
var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(KeyName, Key);
var listener = new HybridConnectionListener(new Uri(string.Format("sb://{0}/{1}", RelayNamespace, ConnectionName)), tokenProvider);
// Subscribe to the status events
listener.Connecting += (o, e) => { Console.WriteLine("Connecting"); };
listener.Offline += (o, e) => { Console.WriteLine("Offline"); };
listener.Online += (o, e) => { Console.WriteLine("Online"); };
// Establish the control channel to the Azure Relay service
await listener.OpenAsync(cts.Token);
Console.WriteLine("Server listening");
// Providing callback for cancellation token that will close the listener.
cts.Token.Register(() => listener.CloseAsync(CancellationToken.None));
// Start a new thread that will continuously read the console.
new Task(() =>
Console.In.ReadLineAsync().ContinueWith((s) => { cts.Cancel(); })).Start();
// Accept the next available, pending connection request.
while (true)
{
var relayConnection = await listener.AcceptConnectionAsync();
if (relayConnection == null)
{
break;
}
ProcessMessagesOnConnection(relayConnection, cts);
}
// Close the listener after we exit the processing loop
await listener.CloseAsync(cts.Token);
}
public HybridConnectionListener CreateHybridListener(string hybridConnectionName, string responseMessage)
{
RelayConnectionStringBuilder connectionStringBuilder = new RelayConnectionStringBuilder(Connections.HybridRelayConnectionString)
{
EntityPath = hybridConnectionName
};
//var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(connectionStringBuilder.SharedAccessKeyName, connectionStringBuilder.SharedAccessKey);
//var uri = new Uri(string.Format("https://{0}/{1}", connectionStringBuilder.Endpoint.Host, hybridConnectionName));
var listener = new HybridConnectionListener(connectionStringBuilder.ToString());
// Subscribe to the status events.
listener.Connecting += (o, e) => { Console.WriteLine("Connecting"); };
listener.Offline += (o, e) => { Console.WriteLine("Offline"); };
listener.Online += (o, e) => { Console.WriteLine("Online"); };
// Provide an HTTP request handler
listener.RequestHandler = (context) =>
{
// Do something with context.Request.Url, HttpMethod, Headers, InputStream...
context.Response.StatusCode = HttpStatusCode.OK;
context.Response.StatusDescription = "OK";
using (var sw = new StreamWriter(context.Response.OutputStream))
{
sw.Write(responseMessage);
}
// The context MUST be closed here
context.Response.Close();
};
listener.OpenAsync().Wait();
Console.WriteLine("Server listening");
return(listener);
}
private async Task OpenAsync()
{
var tokenProvider =
TokenProvider.CreateSharedAccessSignatureTokenProvider(_heHybridConnectionSetting.KeyName,
_heHybridConnectionSetting.Key);
_listener = new HybridConnectionListener(
new Uri(
$"sb://{_heHybridConnectionSetting.RelayNamespace}/{_heHybridConnectionSetting.ConnectionName}"),
tokenProvider)
{
RequestHandler = context =>
{
var content = new StreamReader(context.Request.InputStream).ReadToEnd();
var eventGridEvent = JsonConvert.DeserializeObject <List <EventGridEvent> >(content);
_eventGridEvents.AddRange(eventGridEvent);
}
};
await _listener.OpenAsync();
while (!_stopThread)
{
await Task.Delay(500);
}
}
static async Task RunAsync(string[] args)
{
if (args.Length < 4)
{
Console.WriteLine("dotnet server [ns] [hc] [keyname] [key]");
return;
}
var ns = args[0];
var hc = args[1];
var keyname = args[2];
var key = args[3];
var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(keyname, key);
var listener = new HybridConnectionListener(new Uri(string.Format("sb://{0}/{1}", ns, hc)), tokenProvider);
// TODO:
// use this code (line 36) to hard code a specific proxy URL.
//var webProxy = new WebProxy("http://192.168.1.140:808");
// TODO:
// use this code (line 40) to use the system settings for the user running the code. Lines 40, 41 were added to original sample
var webProxy = HttpWebRequest.DefaultWebProxy;
listener.Proxy = webProxy;
// Subscribe to the status events.
listener.Connecting += (o, e) => { Console.WriteLine("Connecting"); };
listener.Offline += (o, e) => { Console.WriteLine("Offline"); };
listener.Online += (o, e) => { Console.WriteLine("Online"); };
// Provide an HTTP request handler
listener.RequestHandler = (context) =>
{
// Do something with context.Request.Url, HttpMethod, Headers, InputStream...
context.Response.StatusCode = HttpStatusCode.OK;
context.Response.StatusDescription = "OK";
using (var sw = new StreamWriter(context.Response.OutputStream))
{
sw.WriteLine("hello client, this is server speaking!");
}
// The context MUST be closed here
context.Response.Close();
};
// Opening the listener establishes the control channel to
// the Azure Relay service. The control channel is continuously
// maintained, and is reestablished when connectivity is disrupted.
await listener.OpenAsync();
Console.WriteLine("Server listening");
// Start a new thread that will continuously read the console.
await Console.In.ReadLineAsync();
// Close the listener
await listener.CloseAsync();
}
static async Task RunAsync(string[] args)
{
var ns = "<your namespace url from shared access policy- just the fdqn no protocols>";
var hc = "<your hybrid connection name - can be found in portal under the relay>"; //This is the name for the current store - one per store to be cofigured when running the service in the store
var keyname = "<shared access key name such as RootManageSharedAccessKey>";
var key = "<key value from the shared access policies>";
var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(keyname, key);
var listener = new HybridConnectionListener(new Uri(string.Format("sb://{0}/{1}", ns, hc)), tokenProvider);
// Subscribe to the status events.
listener.Connecting += (o, e) => { Console.WriteLine("Connecting"); };
listener.Offline += (o, e) => { Console.WriteLine("Offline"); };
listener.Online += (o, e) => { Console.WriteLine("Online"); };
// Provide an HTTP request handler
listener.RequestHandler = (context) =>
{
// Do something with context.Request.Url, HttpMethod, Headers, InputStream...
var contextRequest = context.Request;
System.IO.Stream body = contextRequest.InputStream;
System.IO.StreamReader reader = new System.IO.StreamReader(body, Encoding.UTF8);
string targetUrl = reader.ReadToEnd();
body.Close();
context.Response.StatusCode = HttpStatusCode.OK;
context.Response.StatusDescription = "OK";
string result = "";
using (var sw = new StreamWriter(context.Response.OutputStream))
{
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(targetUrl);
request.Method = "Get";
request.KeepAlive = true;
HttpWebResponse response = (HttpWebResponse)request.GetResponse();
using (System.IO.StreamReader sr = new System.IO.StreamReader(response.GetResponseStream()))
{
result = sr.ReadToEnd();
}
Console.WriteLine(result);
sw.WriteLine(result);
}
context.Response.Close();
};
// Opening the listener establishes the control channel to
// the Azure Relay service. The control channel is continuously
// maintained, and is reestablished when connectivity is disrupted.
await listener.OpenAsync();
Console.WriteLine("Server listening");
// Start a new thread that will continuously read the console.
await Console.In.ReadLineAsync();
// Close the listener
await listener.CloseAsync();
}
async Task RawWebSocketSenderTest(EndpointTestType endpointTestType)
{
HybridConnectionListener listener = null;
try
{
listener = GetHybridConnectionListener(endpointTestType);
var clientWebSocket = new ClientWebSocket();
var wssUri = await GetWebSocketConnectionUri(endpointTestType);
using (var cancelSource = new CancellationTokenSource(TimeSpan.FromMinutes(1)))
{
TestUtility.Log($"Opening {listener}");
await listener.OpenAsync(cancelSource.Token);
await clientWebSocket.ConnectAsync(wssUri, cancelSource.Token);
var listenerStream = await listener.AcceptConnectionAsync();
TestUtility.Log("Client and Listener are connected!");
Assert.Null(clientWebSocket.SubProtocol);
byte[] sendBuffer = this.CreateBuffer(1024, new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
await clientWebSocket.SendAsync(new ArraySegment <byte>(sendBuffer), WebSocketMessageType.Binary, true, cancelSource.Token);
TestUtility.Log($"clientWebSocket wrote {sendBuffer.Length} bytes");
byte[] readBuffer = new byte[sendBuffer.Length];
await this.ReadCountBytesAsync(listenerStream, readBuffer, 0, readBuffer.Length, TimeSpan.FromSeconds(30));
Assert.Equal(sendBuffer, readBuffer);
TestUtility.Log("Calling clientStream.CloseAsync");
var clientStreamCloseTask = clientWebSocket.CloseAsync(WebSocketCloseStatus.EndpointUnavailable, "From Test Code", cancelSource.Token);
TestUtility.Log("Reading from listenerStream");
int bytesRead = await this.SafeReadAsync(listenerStream, readBuffer, 0, readBuffer.Length);
TestUtility.Log($"listenerStream.Read returned {bytesRead} bytes");
Assert.Equal(0, bytesRead);
TestUtility.Log("Calling listenerStream.CloseAsync");
var listenerStreamCloseTask = listenerStream.CloseAsync(cancelSource.Token);
await listenerStreamCloseTask;
TestUtility.Log("Calling listenerStream.CloseAsync completed");
await clientStreamCloseTask;
TestUtility.Log("Calling clientStream.CloseAsync completed");
TestUtility.Log($"Closing {listener}");
await listener.CloseAsync(TimeSpan.FromSeconds(10));
listener = null;
}
}
finally
{
await this.SafeCloseAsync(listener);
}
}
public async Task OpenAsync(CancellationToken cancelToken)
{
_listener.RequestHandler = ListenerRequestHandler;
await _listener.OpenAsync(cancelToken);
Console.WriteLine("Azure Service Bus is listening on \n\r\t{0}\n\rand routing requests to \n\r\t{1}\n\r\n\r", _listener.Address, _httpClient.BaseAddress);
Console.WriteLine("Press [Enter] to exit");
}
public async Task OpenAsync(CancellationToken cancelToken)
{
listener.RequestHandler = (context) => this.RequestHandler(context);
await listener.OpenAsync(cancelToken);
Console.WriteLine($"Forwarding from {listener.Address} to {httpClient.BaseAddress}.");
Console.WriteLine("utcTime, request, statusCode, durationMs");
}
static async Task RunAsync(string[] args)
{
if (args.Length < 4)
{
Console.WriteLine("dotnet server [ns] [hc] [keyname] [key]");
return;
}
var ns = args[0];
var hc = args[1];
var keyname = args[2];
var key = args[3];
var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(keyname, key);
var listener = new HybridConnectionListener(new Uri(string.Format("sb://{0}/{1}", ns, hc)), tokenProvider);
// Subscribe to the status events.
listener.Connecting += (o, e) => { Console.WriteLine("Connecting"); };
listener.Offline += (o, e) => { Console.WriteLine("Offline"); };
listener.Online += (o, e) => { Console.WriteLine("Online"); };
// Provide an HTTP request handler
listener.RequestHandler = async(context) =>
{
// Do something with context.Request.Url, HttpMethod, Headers, InputStream...
Console.WriteLine();
Console.WriteLine("=====HEADERS=====");
Console.WriteLine(context.Request.Headers.ToString());
Console.WriteLine("=====BODY=====");
using (var sr = new StreamReader(context.Request.InputStream))
{
Console.WriteLine(await sr.ReadToEndAsync());
}
context.Response.StatusCode = HttpStatusCode.OK;
context.Response.StatusDescription = "OK";
using (var sw = new StreamWriter(context.Response.OutputStream))
{
sw.WriteLine("hello!");
}
// The context MUST be closed here
context.Response.Close();
};
// Opening the listener establishes the control channel to
// the Azure Relay service. The control channel is continuously
// maintained, and is reestablished when connectivity is disrupted.
await listener.OpenAsync();
Console.WriteLine("Server listening");
// Start a new thread that will continuously read the console.
await Console.In.ReadLineAsync();
// Close the listener
await listener.CloseAsync();
}
async Task WriteLargeDataSetTest(EndpointTestType endpointTestType, int kilobytesToSend = 1024)
{
HybridConnectionListener listener = null;
try
{
listener = GetHybridConnectionListener(endpointTestType);
var client = GetHybridConnectionClient(endpointTestType);
TestUtility.Log($"Opening {listener}");
await listener.OpenAsync(TimeSpan.FromSeconds(30));
var clientStream = await client.CreateConnectionAsync();
var listenerStream = await listener.AcceptConnectionAsync();
TestUtility.Log($"clientStream and listenerStream connected! {listenerStream}");
byte[] sendBuffer = this.CreateBuffer(kilobytesToSend * 1024, new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
byte[] readBuffer = new byte[sendBuffer.Length];
TestUtility.Log($"Sending {sendBuffer.Length} bytes from client->listener");
var sendTask = clientStream.WriteAsync(sendBuffer, 0, sendBuffer.Length);
var readTask = this.ReadCountBytesAsync(listenerStream, readBuffer, 0, readBuffer.Length, TimeSpan.FromSeconds(30));
await Task.WhenAll(sendTask, readTask);
TestUtility.Log($"Sending and Reading complete");
Assert.Equal(sendBuffer, readBuffer);
TestUtility.Log($"Sending {sendBuffer.Length} bytes from listener->client");
sendTask = listenerStream.WriteAsync(sendBuffer, 0, sendBuffer.Length);
readTask = this.ReadCountBytesAsync(clientStream, readBuffer, 0, readBuffer.Length, TimeSpan.FromSeconds(30));
await Task.WhenAll(sendTask, readTask);
TestUtility.Log($"Sending and Reading complete");
Assert.Equal(sendBuffer, readBuffer);
TestUtility.Log("Calling clientStream.Shutdown");
clientStream.Shutdown();
int bytesRead = await this.SafeReadAsync(listenerStream, readBuffer, 0, readBuffer.Length);
TestUtility.Log($"listenerStream.Read returned {bytesRead} bytes");
Assert.Equal(0, bytesRead);
TestUtility.Log("Calling listenerStream.Dispose");
listenerStream.Dispose();
TestUtility.Log("Calling clientStream.Dispose");
clientStream.Dispose();
}
finally
{
await this.SafeCloseAsync(listener);
}
}
async Task Verbs()
{
var endpointTestType = EndpointTestType.Authenticated;
HybridConnectionListener listener = this.GetHybridConnectionListener(endpointTestType);
try
{
RelayConnectionStringBuilder connectionString = GetConnectionStringBuilder(endpointTestType);
Uri endpointUri = connectionString.Endpoint;
TestUtility.Log("Calling HybridConnectionListener.Open");
await listener.OpenAsync(TimeSpan.FromSeconds(30));
Uri hybridHttpUri = new UriBuilder("https://", endpointUri.Host, endpointUri.Port, connectionString.EntityPath).Uri;
using (var client = new HttpClient {
BaseAddress = hybridHttpUri
})
{
client.DefaultRequestHeaders.ExpectContinue = false;
HttpMethod[] methods = new HttpMethod[]
{
HttpMethod.Delete, HttpMethod.Get, HttpMethod.Head, HttpMethod.Options, HttpMethod.Post, HttpMethod.Put, HttpMethod.Trace
};
foreach (HttpMethod method in methods)
{
TestUtility.Log($"Testing HTTP Verb: {method}");
string actualMethod = string.Empty;
listener.RequestHandler = (context) =>
{
TestUtility.Log($"RequestHandler: {context.Request.HttpMethod} {context.Request.Url}");
actualMethod = context.Request.HttpMethod;
context.Response.Close();
};
var request = new HttpRequestMessage();
await AddAuthorizationHeader(connectionString, request, hybridHttpUri);
request.Method = method;
LogRequestLine(request, client);
using (HttpResponseMessage response = await client.SendAsync(request))
{
TestUtility.Log($"Response: HTTP/{response.Version} {(int)response.StatusCode} {response.ReasonPhrase}");
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(method.Method, actualMethod);
}
}
}
await listener.CloseAsync(TimeSpan.FromSeconds(10));
}
finally
{
await SafeCloseAsync(listener);
}
}
async Task EmptyRequestEmptyResponse(EndpointTestType endpointTestType)
{
var cts = new CancellationTokenSource(TimeSpan.FromSeconds(60));
HybridConnectionListener listener = this.GetHybridConnectionListener(endpointTestType);
try
{
await listener.OpenAsync(cts.Token);
listener.RequestHandler = async(context) =>
{
TestUtility.Log($"RequestHandler: {context.Request.HttpMethod} {context.Request.Url}");
await context.Response.CloseAsync();
};
RelayConnectionStringBuilder connectionString = GetConnectionStringBuilder(endpointTestType);
Uri endpointUri = connectionString.Endpoint;
Uri hybridHttpUri = new UriBuilder("https://", endpointUri.Host, endpointUri.Port, connectionString.EntityPath).Uri;
using (var client = new HttpClient {
BaseAddress = hybridHttpUri
})
{
client.DefaultRequestHeaders.ExpectContinue = false;
var getRequest = new HttpRequestMessage();
getRequest.Method = HttpMethod.Get;
await AddAuthorizationHeader(connectionString, getRequest, hybridHttpUri);
LogRequest(getRequest, client);
using (HttpResponseMessage response = await client.SendAsync(getRequest))
{
LogResponse(response);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(0, response.Content.ReadAsStreamAsync().Result.Length);
}
var postRequest = new HttpRequestMessage();
postRequest.Method = HttpMethod.Post;
await AddAuthorizationHeader(connectionString, postRequest, hybridHttpUri);
LogRequest(postRequest, client);
using (HttpResponseMessage response = await client.SendAsync(postRequest))
{
LogResponse(response);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(0, response.Content.ReadAsStreamAsync().Result.Length);
}
}
await listener.CloseAsync(cts.Token);
}
finally
{
await SafeCloseAsync(listener);
}
}
async Task ClientShutdownTest(EndpointTestType endpointTestType)
{
HybridConnectionListener listener = null;
try
{
listener = GetHybridConnectionListener(endpointTestType);
var client = GetHybridConnectionClient(endpointTestType);
TestUtility.Log($"Opening {listener}");
await listener.OpenAsync(TimeSpan.FromSeconds(30));
var clientStream = await client.CreateConnectionAsync();
var listenerStream = await listener.AcceptConnectionAsync();
TestUtility.Log("Client and Listener HybridStreams are connected!");
byte[] sendBuffer = this.CreateBuffer(1024, new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
await clientStream.WriteAsync(sendBuffer, 0, sendBuffer.Length);
TestUtility.Log($"clientStream wrote {sendBuffer.Length} bytes");
byte[] readBuffer = new byte[sendBuffer.Length];
await this.ReadCountBytesAsync(listenerStream, readBuffer, 0, readBuffer.Length, TimeSpan.FromSeconds(30));
Assert.Equal(sendBuffer, readBuffer);
TestUtility.Log("Calling clientStream.Shutdown");
clientStream.Shutdown();
int bytesRead = await this.SafeReadAsync(listenerStream, readBuffer, 0, readBuffer.Length);
TestUtility.Log($"listenerStream.Read returned {bytesRead} bytes");
Assert.Equal(0, bytesRead);
TestUtility.Log("Calling listenerStream.Shutdown and Dispose");
listenerStream.Shutdown();
listenerStream.Dispose();
bytesRead = await this.SafeReadAsync(clientStream, readBuffer, 0, readBuffer.Length);
TestUtility.Log($"clientStream.Read returned {bytesRead} bytes");
Assert.Equal(0, bytesRead);
TestUtility.Log("Calling clientStream.Dispose");
clientStream.Dispose();
TestUtility.Log($"Closing {listener}");
await listener.CloseAsync(TimeSpan.FromSeconds(10));
listener = null;
}
finally
{
await this.SafeCloseAsync(listener);
}
}
async Task NonExistantNamespaceTest(EndpointTestType endpointTestType)
{
HybridConnectionListener listener = null;
try
{
TestUtility.Log("Setting ConnectionStringBuilder.Endpoint to 'sb://fakeendpoint.com'");
var fakeEndpointConnectionStringBuilder = new RelayConnectionStringBuilder(this.ConnectionString)
{
Endpoint = new Uri("sb://fakeendpoint.com")
};
if (endpointTestType == EndpointTestType.Authenticated)
{
fakeEndpointConnectionStringBuilder.EntityPath = Constants.AuthenticatedEntityPath;
}
else
{
fakeEndpointConnectionStringBuilder.EntityPath = Constants.UnauthenticatedEntityPath;
}
var fakeEndpointConnectionString = fakeEndpointConnectionStringBuilder.ToString();
listener = new HybridConnectionListener(fakeEndpointConnectionString);
var client = new HybridConnectionClient(fakeEndpointConnectionString);
// TODO: Remove this once .NET Core supports inspecting the StatusCode/Description. https://github.com/dotnet/corefx/issues/13773
#if NET451
await Assert.ThrowsAsync <EndpointNotFoundException>(() => listener.OpenAsync());
await Assert.ThrowsAsync <EndpointNotFoundException>(() => client.CreateConnectionAsync());
#else
await Assert.ThrowsAsync <RelayException>(() => listener.OpenAsync());
await Assert.ThrowsAsync <RelayException>(() => client.CreateConnectionAsync());
#endif
}
finally
{
await this.SafeCloseAsync(listener);
}
}
private static async Task RunAsync()
{
// Create the listener
var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(KeyName, Key);
var listener = new HybridConnectionListener(new Uri($"sb://{RelayNamespace}/{ConnectionName}"), tokenProvider);
// Subscribe to the status events
listener.Connecting += (o, e) => { Console.WriteLine("Connecting"); };
listener.Offline += (o, e) => { Console.WriteLine("Check service is offline"); };
listener.Online += (o, e) => { Console.WriteLine("Check service is online"); };
// Create an array of credit status values
var statuses = new List <string>
{
"Good",
"Some issues",
"Bad"
};
// Provide an HTTP request handler
listener.RequestHandler = (context) =>
{
// Obtain the name from the request
var reader = new StreamReader(context.Request.InputStream);
var requestedName = reader.ReadToEnd();
Console.WriteLine("A request was received to check status for: " + requestedName);
// Pick a status at random
Random r = new Random();
var index = r.Next(statuses.Count);
// Formulate and send the response
context.Response.StatusCode = HttpStatusCode.OK;
context.Response.StatusDescription = "Status check successful";
using (var writer = new StreamWriter(context.Response.OutputStream))
{
writer.WriteLine($"Status check for {requestedName}: {statuses[index]}");
}
// Close the context
context.Response.Close();
};
// Open the listener
await listener.OpenAsync();
Console.WriteLine("Server listening");
// Start a new thread that will continuously read the console.
await Console.In.ReadLineAsync();
// Close the listener after you exit the processing loop.
await listener.CloseAsync();
}
private static async Task RunAsync()
{
var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(KeyName, Key);
var listener = new HybridConnectionListener(new Uri(string.Format("sb://{0}/{1}", RelayNamespace, ConnectionName)), tokenProvider);
// Subscribe to the status events.
listener.Connecting += (o, e) => { Console.WriteLine("Connecting"); };
listener.Offline += (o, e) => { Console.WriteLine("Offline"); };
listener.Online += (o, e) => { Console.WriteLine("Online"); };
// Provide an HTTP request handler
listener.RequestHandler = (context) =>
{
if (context.Request.HttpMethod.Contains("POST"))
{
// Do something with context.Request.Url, HttpMethod, Headers, InputStream...
context.Response.StatusCode = HttpStatusCode.OK;
context.Response.StatusDescription = "OK";
var body = new StreamReader(context.Request.InputStream).ReadToEnd();
using (var sw = new StreamWriter(context.Response.OutputStream))
{
sw.WriteLine("hello");
}
}
if (context.Request.HttpMethod.Contains("GET"))
{
// Do something with context.Request.Url, HttpMethod, Headers, InputStream...
context.Response.StatusCode = HttpStatusCode.OK;
context.Response.StatusDescription = "OK";
using (var sw = new StreamWriter(context.Response.OutputStream))
{
sw.WriteLine("world!");
}
}
// The context MUST be closed here
context.Response.Close();
};
// Opening the listener establishes the control channel to
// the Azure Relay service. The control channel is continuously
// maintained, and is reestablished when connectivity is disrupted.
await listener.OpenAsync();
Console.WriteLine("Server listening");
// Start a new thread that will continuously read the console.
await Console.In.ReadLineAsync();
// Close the listener after you exit the processing loop.
await listener.CloseAsync();
}
async Task HybridConnectionTest(EndpointTestType endpointTestType, bool useBuiltInClientWebSocket)
{
HybridConnectionListener listener = null;
try
{
listener = this.GetHybridConnectionListener(endpointTestType);
listener.UseBuiltInClientWebSocket = useBuiltInClientWebSocket;
var client = GetHybridConnectionClient(endpointTestType);
client.UseBuiltInClientWebSocket = useBuiltInClientWebSocket;
TestUtility.Log($"Opening {listener}");
await listener.OpenAsync(TimeSpan.FromSeconds(30));
var clientStream = await client.CreateConnectionAsync();
var listenerStream = await listener.AcceptConnectionAsync();
TestUtility.Log("Client and Listener HybridStreams are connected!");
byte[] sendBuffer = this.CreateBuffer(1024, new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
await clientStream.WriteAsync(sendBuffer, 0, sendBuffer.Length);
TestUtility.Log($"clientStream wrote {sendBuffer.Length} bytes");
byte[] readBuffer = new byte[sendBuffer.Length];
await this.ReadCountBytesAsync(listenerStream, readBuffer, 0, readBuffer.Length, TimeSpan.FromSeconds(30));
Assert.Equal(sendBuffer, readBuffer);
TestUtility.Log("Calling clientStream.CloseAsync");
var clientStreamCloseTask = clientStream.CloseAsync(new CancellationTokenSource(TimeSpan.FromSeconds(10)).Token);
TestUtility.Log("Reading from listenerStream");
int bytesRead = await this.SafeReadAsync(listenerStream, readBuffer, 0, readBuffer.Length);
TestUtility.Log($"listenerStream.Read returned {bytesRead} bytes");
Assert.Equal(0, bytesRead);
TestUtility.Log("Calling listenerStream.CloseAsync");
var listenerStreamCloseTask = listenerStream.CloseAsync(new CancellationTokenSource(TimeSpan.FromSeconds(10)).Token);
await listenerStreamCloseTask;
TestUtility.Log("Calling listenerStream.CloseAsync completed");
await clientStreamCloseTask;
TestUtility.Log("Calling clientStream.CloseAsync completed");
TestUtility.Log($"Closing {listener}");
await listener.CloseAsync(TimeSpan.FromSeconds(10));
listener = null;
}
finally
{
await this.SafeCloseAsync(listener);
}
}
private static async Task RunAsync()
{
var cts = new CancellationTokenSource();
// var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(KeyName, myKey);
// var listener = new HybridConnectionListener(new Uri(string.Format("sb://{0}/{1}", RelayNamespace, ConnectionName)), tokenProvider);
var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(KeyName, myKey);
var listener = new HybridConnectionListener(new Uri(String.Format("sb://{0}/{1}", RelayNamespace, ConnectionName)), tokenProvider);
// Subscribe to the status events
Console.BackgroundColor = ConsoleColor.Yellow;
Console.ForegroundColor = ConsoleColor.Black;
listener.Connecting += (o, e) => { Console.WriteLine("Connecting"); };
listener.Offline += (o, e) => { Console.WriteLine("Offline"); };
listener.Online += (o, e) => { Console.WriteLine("Online"); };
// Opening the listener will establish the control channel to
// the Azure Relay service. The control channel will be continuously
// maintained and reestablished when connectivity is disrupted.
await listener.OpenAsync(cts.Token);
Console.BackgroundColor = ConsoleColor.Yellow;
Console.ForegroundColor = ConsoleColor.Black;
Console.WriteLine("Server " + RelayNamespace + " is listening...");
Console.BackgroundColor = ConsoleColor.Black;
Console.ForegroundColor = ConsoleColor.White;
// Providing callback for cancellation token that will close the listener.
cts.Token.Register(() => listener.CloseAsync(CancellationToken.None));
// Start a new thread that will continuously read the console.
new Task(() => Console.In.ReadLineAsync().ContinueWith((s) => { cts.Cancel(); })).Start();
// Accept the next available, pending connection request.
// Shutting down the listener will allow a clean exit with
// this method returning null
while (true)
{
var relayConnection = await listener.AcceptConnectionAsync();
if (relayConnection == null)
{
break;
}
ProcessMessagesOnConnection(relayConnection, cts);
}
// Close the listener after we exit the processing loop
await listener.CloseAsync(cts.Token);
}
private static async Task RunAsync()
{
var cts = new CancellationTokenSource();
var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(KeyName, Key);
var listener = new HybridConnectionListener(new Uri(string.Format("sb://{0}/{1}", RelayNamespace, ConnectionName)), tokenProvider);
// Subscribe to the status events
listener.Connecting += (o, e) => { Console.WriteLine("Connecting"); };
listener.Offline += (o, e) => { Console.WriteLine("Credit check service is offline"); };
listener.Online += (o, e) => { Console.WriteLine("Credit check service is online"); };
// Create an array of credit status values
List <string> creditStatuses = new List <string>();
creditStatuses.Add("Good");
creditStatuses.Add("Some issues");
creditStatuses.Add("Bad");
// Provide an HTTP request handler
listener.RequestHandler = (context) =>
{
// Obtain the name from the request
TextReader tr = new StreamReader(context.Request.InputStream);
String requestedName = tr.ReadToEnd();
Console.WriteLine("A request was received to check credit for: " + requestedName);
// Pick a status at random
Random r = new Random();
int index = r.Next(creditStatuses.Count);
// Formulate and send the response
context.Response.StatusCode = HttpStatusCode.OK;
context.Response.StatusDescription = "Credit check successful";
using (var sw = new StreamWriter(context.Response.OutputStream))
{
sw.WriteLine("Credit check for {0}: {1}", requestedName, creditStatuses[index]);
}
// Close the context
context.Response.Close();
};
// Open the listener
await listener.OpenAsync();
Console.WriteLine("Server listening");
// Start a new thread that will continuously read the console.
await Console.In.ReadLineAsync();
// Close the listener after you exit the processing loop.
await listener.CloseAsync();
}
async Task LargeRequestEmptyResponse(EndpointTestType endpointTestType)
{
var cts = new CancellationTokenSource(TimeSpan.FromSeconds(60));
HybridConnectionListener listener = this.GetHybridConnectionListener(endpointTestType);
try
{
await listener.OpenAsync(cts.Token);
string requestBody = null;
listener.RequestHandler = async(context) =>
{
TestUtility.Log("HybridConnectionListener.RequestHandler invoked with Request:");
TestUtility.Log($"{context.Request.HttpMethod} {context.Request.Url}");
context.Request.Headers.AllKeys.ToList().ForEach((k) => TestUtility.Log($"{k}: {context.Request.Headers[k]}"));
requestBody = StreamToString(context.Request.InputStream);
TestUtility.Log($"Body Length: {requestBody.Length}");
await context.Response.CloseAsync();
};
RelayConnectionStringBuilder connectionString = GetConnectionStringBuilder(endpointTestType);
Uri endpointUri = connectionString.Endpoint;
Uri hybridHttpUri = new UriBuilder("https://", endpointUri.Host, endpointUri.Port, connectionString.EntityPath).Uri;
using (var client = new HttpClient {
BaseAddress = hybridHttpUri
})
{
client.DefaultRequestHeaders.ExpectContinue = false;
var postRequest = new HttpRequestMessage();
await AddAuthorizationHeader(connectionString, postRequest, hybridHttpUri);
postRequest.Method = HttpMethod.Post;
var body = new string('y', 65 * 1024);
postRequest.Content = new StringContent(body);
LogRequest(postRequest, client, showBody: false);
using (HttpResponseMessage response = await client.SendAsync(postRequest, cts.Token))
{
LogResponse(response);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(0, response.Content.ReadAsStreamAsync().Result.Length);
Assert.Equal(body.Length, requestBody.Length);
}
}
await listener.CloseAsync(cts.Token);
}
finally
{
await SafeCloseAsync(listener);
}
}
private async Task RunAsync()
{
// Create a new hybrid connection client
var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(keyName, key);
var listener = new HybridConnectionListener(new Uri($"sb://{relayNamespace}/{connectionName}"), tokenProvider);
// Open the listener and register it in Service Bus
var cts = new CancellationTokenSource();
await listener.OpenAsync(cts.Token);
// Callback for cancellation token that will close the listener
cts.Token.Register(() => listener.CloseAsync(CancellationToken.None));
await Listen(listener, cts)
.ContinueWith((t) => listener.CloseAsync(cts.Token));
}
public void Start()
{
_log.Information("Relay: {idx}:{relay}. Opening relay listener connection", _forwarderIdx, _relayListener.Address);
try
{
_relayListener.OpenAsync(CancellationToken.None).GetAwaiter().GetResult();
_relayListener.AcceptConnectionAsync().ContinueWith(StreamAccepted);
}
catch (Exception e)
{
_log.Error(e, "Relay: {idx}:{relay}. Unable to connect", _forwarderIdx, _relayListener.Address);
throw;
}
}
private static async Task RunAsync()
{
var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(KeyName, Key);
var listener = new HybridConnectionListener(new Uri(string.Format("sb://{0}/{1}", RelayNamespace, ConnectionName)), tokenProvider);
// Subscribe to the status events.
listener.Connecting += (o, e) => { Console.WriteLine("Connecting"); };
listener.Offline += (o, e) => { Console.WriteLine("Offline"); };
listener.Online += (o, e) => { Console.WriteLine("Online"); };
// Provide an HTTP request handler
listener.RequestHandler = (context) =>
{
var name = context.Request.Headers["PassThrough"];
// Do something with context.Request.Url, HttpMethod, Headers, InputStream...
context.Response.StatusCode = HttpStatusCode.OK;
context.Response.StatusDescription = "OK";
var env = new StringBuilder();
env.Append($"Machine Name = {Environment.MachineName}\r\n");
env.Append($"OS Version = {Environment.OSVersion}\r\n");
env.Append($"Current Directory = {Environment.CurrentDirectory}\r\n");
env.Append($"Current User = {Environment.UserName}\r\n");
using (var sw = new StreamWriter(context.Response.OutputStream))
{
sw.WriteLine(env.ToString());
sw.WriteLine("hello, " + name);
}
Console.WriteLine("request from " + name);
// The context MUST be closed here
context.Response.Close();
};
// Opening the listener establishes the control channel to
// the Azure Relay service. The control channel is continuously
// maintained, and is reestablished when connectivity is disrupted.
await listener.OpenAsync();
Console.WriteLine("Server listening");
// Start a new thread that will continuously read the console.
await Console.In.ReadLineAsync();
// Close the listener after you exit the processing loop.
await listener.CloseAsync();
}
/// <summary>
/// Opens the listener and starts listening thread
/// </summary>
private async Task OpenAsync()
{
_listener = new HybridConnectionListener(_uri, _tokenProvider);
// Subscribe to the status events
_listener.Connecting += (o, e) => OnConnecting(o, e);
_listener.Offline += (o, e) => OnDisconnected(o, e);
_listener.Online += (o, e) => OnConnected(o, e);
_listener.AcceptHandler = (c) => OnAcceptAsync(c);
await _listener.OpenAsync(_cts.Token).ConfigureAwait(false);
_listenerTask = Task.Factory.StartNew(async() => await ListenAsync(), _cts.Token,
TaskCreationOptions.LongRunning, TaskScheduler.Default).Unwrap();
ProxyEventSource.Log.LocalListenerStarted(this);
}
private static async Task RunAsync()
{
var cts = new CancellationTokenSource();
var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(KeyName, Key);
var listener = new HybridConnectionListener(new Uri(string.Format("sb://{0}/{1}", RelayNamespace, ConnectionName)), tokenProvider);
// Subscribe to the status events.
listener.Connecting += (o, e) => { Console.WriteLine("Connecting"); };
listener.Offline += (o, e) => { Console.WriteLine("Offline"); };
listener.Online += (o, e) => { Console.WriteLine("Online"); };
// Provide an HTTP request handler
listener.RequestHandler = (context) =>
{
// Do something with context.Request.Url, HttpMethod, Headers, InputStream...
context.Response.StatusCode = HttpStatusCode.OK;
context.Response.StatusDescription = "OK, This is pretty neat";
var bytes = new byte[context.Request.InputStream.Length];
var aaa = context.Request.InputStream.Read(bytes, 0, bytes.Length);
var str = Encoding.UTF8.GetString(bytes);
using (var sw = new StreamWriter(context.Response.OutputStream))
{
sw.WriteLine(str);
Console.WriteLine(str);
}
// The context MUST be closed here
context.Response.Close();
};
// Opening the listener establishes the control channel to
// the Azure Relay service. The control channel is continuously
// maintained, and is reestablished when connectivity is disrupted.
await listener.OpenAsync();
Console.WriteLine("Server listening");
// Start a new thread that will continuously read the console.
await Console.In.ReadLineAsync();
// Close the listener after you exit the processing loop.
await listener.CloseAsync();
}
public async Task <bool> OpenService()
{
try
{
await relayListener.OpenAsync(CancellationToken.None);
#pragma warning disable 4014
relayListener.AcceptConnectionAsync().ContinueWith(t => StreamAccepted(t.Result));
#pragma warning restore 4014
}
catch (Exception e)
{
Trace.TraceError("Unable to connect: {0}", e.Message);
return(false);
}
return(true);
}