async Task ProcessRequestAsync(HttpContext context, IWebSocketListener listener, string correlationId)
{
Preconditions.CheckNotNull(context, nameof(context));
Preconditions.CheckNotNull(context.Connection, nameof(context.Connection));
Preconditions.CheckNotNull(context.Connection.RemoteIpAddress, nameof(context.Connection.RemoteIpAddress));
Preconditions.CheckNotNull(correlationId, nameof(correlationId));
Events.WebSocketSubProtocolSelected(context.TraceIdentifier, listener.SubProtocol, correlationId);
WebSocket webSocket = await context.WebSockets.AcceptWebSocketAsync(listener.SubProtocol);
Option <EndPoint> localEndPoint = Option.None <EndPoint>();
if (context.Connection.LocalIpAddress != null)
{
localEndPoint = Option.Some <EndPoint>(new IPEndPoint(context.Connection.LocalIpAddress, context.Connection.LocalPort));
}
var remoteEndPoint = new IPEndPoint(context.Connection.RemoteIpAddress, context.Connection.RemotePort);
X509Certificate2 cert = await context.Connection.GetClientCertificateAsync();
IAuthenticator proxyAuthenticator = null;
if (cert == null)
{
try
{
var certExtractor = await this.httpProxiedCertificateExtractorProvider;
// if not certificate in header it returns null, no api proxy authentication needed in this case
// if certificate was set in header it means it was forwarded by api proxy and authenticates api proxy by sas token
// and throws AuthenticationException if api proxy was not authenticated or returns the certificate if api proxy authentication succeeded
cert = (await certExtractor.GetClientCertificate(context)).OrDefault();
}
catch (AuthenticationException ex)
{
Events.AuthenticationApiProxyFailed(remoteEndPoint.ToString(), ex);
// Set authenticator to unauthorize the call from subprotocol level (Mqtt or Amqp)
proxyAuthenticator = new NullAuthenticator();
cert = context.GetForwardedCertificate();
}
}
if (cert != null)
{
IList <X509Certificate2> certChain = context.GetClientCertificateChain();
await listener.ProcessWebSocketRequestAsync(webSocket, localEndPoint, remoteEndPoint, correlationId, cert, certChain, proxyAuthenticator);
}
else
{
await listener.ProcessWebSocketRequestAsync(webSocket, localEndPoint, remoteEndPoint, correlationId);
}
Events.WebSocketRequestCompleted(context.TraceIdentifier, correlationId);
}
public Request()
{
applicationName = Utilities.GetAssemblyTitle() ?? "Unknown_Application";
Authenticator = new NullAuthenticator();
WebRequestFactory = new HttpRequestFactory();
Parameters = new ParameterCollection();
MaximumRetries = 3;
RetryWaitTimeIncreaseFactor = 2.0;
RetryInitialWaitTime = 1000;
}
public void SimpleCallTest()
{
var auth = new NullAuthenticator();
var webRequest = new HttpRequestFactory().Create(new Uri("https://www.google.com"), "GET");
auth.ApplyAuthenticationToRequest(webRequest);
Assert.IsNotNull(webRequest);
Assert.That(webRequest.RequestUri, Is.EqualTo(new Uri("https://www.google.com")));
Assert.That(webRequest.Method, Is.EqualTo("GET"));
}
/// <summary>
/// Creates a new http client settings with blank defaults
/// </summary>
public HttpClientSettings()
{
Serializers = new List <ISerializer>();
Authenticator = new NullAuthenticator();
Logger = new NullLogger();
NamingConvention = new DefaultNamingConvention();
UserAgent = SpeakEasy.UserAgent.SpeakEasy;
CookieStrategy = new TransientCookieStrategy();
ArrayFormatter = new MultipleValuesArrayFormatter();
Serializers.Add(new DefaultJsonSerializer());
Serializers.Add(new DotNetXmlSerializer());
}
/// <summary>
/// Creates a new http client settings with blank defaults
/// </summary>
public HttpClientSettings()
{
Serializers = new List <ISerializer>();
Authenticator = new NullAuthenticator();
NamingConvention = new DefaultNamingConvention();
ArrayFormatter = new MultipleValuesArrayFormatter();
Serializers.Add(new DefaultJsonSerializer());
Serializers.Add(new TextPlainSerializer());
Middleware.Append(new TimeoutMiddleware());
Middleware.Append(new UserAgentMiddleware());
}
public GitHubClient(IRestClientFactory factory,
IResponseProcessor processor)
{
Requires.ArgumentNotNull(factory, "factory");
Requires.ArgumentNotNull(processor, "processor");
_factory = factory;
_processor = processor;
Authenticator = new NullAuthenticator();
_users = new UserService(this);
_issues = new IssueService(this);
_repositories = new RepositoryService(this);
_pullRequests = new PullRequestService(this);
_organizations = new OrganizationService(this);
}
public void CallApiAsync_ShouldUseGivenAuthenticator_DuringForRestClient()
{
var expectedAuthenticator = new NullAuthenticator();
var mockFactory = new Mock <IRestClientFactory>(MockBehavior.Strict);
var mockRestClient = new Mock <IRestClient>(MockBehavior.Strict);
mockFactory.Setup <IRestClient>(f => f.CreateRestClient(It.IsAny <string>()))
.Returns(mockRestClient.Object);
mockRestClient
.Setup(c => c.ExecuteAsync <object>(It.IsAny <IRestRequest>(),
It.IsAny <Action <IRestResponse <object>, RestRequestAsyncHandle> >()))
.Returns(_testHandle);
mockRestClient.SetupSet(c => c.Authenticator = expectedAuthenticator)
.Verifiable();
var client = CreateClient(mockFactory.Object);
client.Authenticator = expectedAuthenticator;
client.CallApiAsync <object>(new GitHubRequest("foo", API.v3, NGitHub.Web.Method.GET),
o => { },
e => { });
mockRestClient.Verify();
}
async Task <(IMessageConsumer, IMessageConsumer, NullBrokerConnector)> SetupEnvironment()
{
Routing.UserMetricLogger = NullRoutingUserMetricLogger.Instance;
Routing.PerfCounter = NullRoutingPerfCounter.Instance;
Routing.UserAnalyticsLogger = NullUserAnalyticsLogger.Instance;
var defaultRetryStrategy = new FixedInterval(5, TimeSpan.FromSeconds(5));
var defaultRevivePeriod = TimeSpan.FromHours(1);
var defaultTimeout = TimeSpan.FromSeconds(60);
var endpointExecutorConfig = new EndpointExecutorConfig(defaultTimeout, defaultRetryStrategy, defaultRevivePeriod, true);
var cloudProxyDispatcher = new BrokeredCloudProxyDispatcher();
var cloudConnectionProvider = new BrokeredCloudConnectionProvider(cloudProxyDispatcher);
var identityProvider = new IdentityProvider(iotHubName);
var deviceConnectivityManager = new BrokeredDeviceConnectivityManager(cloudProxyDispatcher);
var connectionManager = new ConnectionManager(cloudConnectionProvider, Mock.Of <ICredentialsCache>(), new IdentityProvider(iotHubName), deviceConnectivityManager);
var routingMessageConverter = new RoutingMessageConverter();
var routeFactory = new EdgeRouteFactory(new EndpointFactory(connectionManager, routingMessageConverter, edgeDeviceId, 10, 10));
var routesList = new[] { routeFactory.Create("FROM /messages INTO $upstream") };
var endpoints = routesList.Select(r => r.Endpoint);
var routerConfig = new RouterConfig(endpoints, routesList);
var dbStoreProvider = new InMemoryDbStoreProvider();
var storeProvider = new StoreProvider(dbStoreProvider);
var messageStore = new MessageStore(storeProvider, CheckpointStore.Create(storeProvider), TimeSpan.MaxValue, false, 1800);
var endpointExecutorFactory = new StoringAsyncEndpointExecutorFactory(endpointExecutorConfig, new AsyncEndpointExecutorOptions(1, TimeSpan.FromMilliseconds(10)), messageStore);
var router = await Router.CreateAsync(Guid.NewGuid().ToString(), iotHubName, routerConfig, endpointExecutorFactory);
var messageConverterProvider = new MessageConverterProvider(
new Dictionary <Type, IMessageConverter>()
{
{ typeof(Twin), new TwinMessageConverter() },
{ typeof(TwinCollection), new TwinCollectionMessageConverter() }
});
var twinManager = TwinManager.CreateTwinManager(connectionManager, messageConverterProvider, Option.None <IStoreProvider>());
var invokeMethodHandler = Mock.Of <IInvokeMethodHandler>();
var subscriptionProcessor = new SubscriptionProcessor(connectionManager, invokeMethodHandler, deviceConnectivityManager);
var edgeHub = new RoutingEdgeHub(router, routingMessageConverter, connectionManager, twinManager, edgeDeviceId, edgeModuleName, invokeMethodHandler, subscriptionProcessor, Mock.Of <IDeviceScopeIdentitiesCache>());
var brokerConnector = new NullBrokerConnector(cloudProxyDispatcher);
cloudProxyDispatcher.SetConnector(brokerConnector);
cloudProxyDispatcher.BindEdgeHub(edgeHub);
var connectionProvider = new ConnectionProvider(connectionManager, edgeHub, TimeSpan.FromSeconds(30));
var authenticator = new NullAuthenticator();
var edgeHubIdentity = new ModuleIdentity(iotHubName, edgeDeviceId, edgeModuleName);
var tokenCredentials = new TokenCredentials(edgeHubIdentity, "qwerty", "test-product", Option.Some("test-model"), Option.None <string>(), false);
var systemComponentProvider = new SystemComponentIdProvider(tokenCredentials);
var connectionHandler = default(ConnectionHandler);
connectionHandler = new ConnectionHandler(
Task.FromResult <IConnectionProvider>(connectionProvider),
Task.FromResult <IAuthenticator>(authenticator),
identityProvider,
systemComponentProvider,
DeviceProxyFactory);
DeviceProxy DeviceProxyFactory(IIdentity identity, bool isDirectClient)
{
return(new DeviceProxy(identity, isDirectClient, connectionHandler, Mock.Of <ITwinHandler>(), Mock.Of <IModuleToModuleMessageHandler>(), Mock.Of <ICloud2DeviceMessageHandler>(), Mock.Of <IDirectMethodHandler>()));
}
var cloud2DeviceMessageHandler = new Cloud2DeviceMessageHandler(connectionHandler);
var moduleToModuleMessageHandler = new ModuleToModuleMessageHandler(connectionHandler, identityProvider, new ModuleToModuleResponseTimeout(TimeSpan.FromSeconds(10)));
var directMethodHandler = new DirectMethodHandler(connectionHandler, identityProvider);
var twinHandler = new TwinHandler(connectionHandler, identityProvider);
var subscriptionChangeHandler = new SubscriptionChangeHandler(
cloud2DeviceMessageHandler,
moduleToModuleMessageHandler,
directMethodHandler,
twinHandler,
connectionHandler,
identityProvider);
return(subscriptionChangeHandler, cloudProxyDispatcher, brokerConnector);
}
