public static T GetCredentialServiceImplementation <T>(this HttpHandlerResourceV3 httpResourceHandler) where T : class, ICredentialService
{
if (HttpHandlerResourceV3.CredentialService is not null)
{
return(HttpHandlerResourceV3.CredentialService.Value as T);
}
throw new InvalidOperationException();
}
public static void ResetCredentials(this HttpHandlerResourceV3 httpResourceHandler)
{
var credentialsService = httpResourceHandler.GetCredentialServiceImplementation <ExplorerCredentialService>();
if (credentialsService is not null)
{
credentialsService.ClearRetryCache();
}
}
public override Task <Tuple <bool, INuGetResource> > TryCreate(SourceRepository source, CancellationToken token)
{
HttpHandlerResourceV3 curResource = null;
if (source.PackageSource.IsHttp)
{
curResource = CreateResource(source.PackageSource);
}
return(Task.FromResult(new Tuple <bool, INuGetResource>(curResource != null, curResource)));
}
internal static async Task <HttpHandlerResource> GetHandlerAsync(Uri index, HttpMessageHandler wrapper)
{
var source = Repository.Factory.GetCoreV3(index.AbsoluteUri);
var handler = await source.GetResourceAsync <HttpHandlerResource>();
if (wrapper != null)
{
handler = new HttpHandlerResourceV3(handler.ClientHandler, wrapper);
}
return(handler);
}
public override Task <Tuple <bool, INuGetResource> > TryCreate(SourceRepository source, CancellationToken token)
{
Debug.Assert(source.PackageSource.IsHttp, "HTTP handler requested for a non-http source.");
HttpHandlerResourceV3 curResource = null;
if (source.PackageSource.IsHttp)
{
curResource = CreateResource(source.PackageSource);
}
return(Task.FromResult(new Tuple <bool, INuGetResource> (curResource != null, curResource)));
}
public override async Task <Tuple <bool, INuGetResource> > TryCreate(SourceRepository source, CancellationToken token)
{
var resource = await _innerResourceProvider.TryCreate(source, token);
if (resource.Item1)
{
var clientHandler = ((HttpHandlerResource)resource.Item2).ClientHandler;
var messageHandler = new NonhijackedV2HttpMessageHandler(((HttpHandlerResource)resource.Item2).MessageHandler);
var httpHandlerResource = new HttpHandlerResourceV3(clientHandler, messageHandler);
resource = new Tuple <bool, INuGetResource>(httpHandlerResource != null, httpHandlerResource);
}
return(resource);
}
internal static HttpHandlerResourceV3 CreateResource(PackageSource packageSource, ICredentialService credentialService, bool nonInteractive = false)
{
var sourceUri = packageSource.SourceUri;
var settings = new HttpClientSettings {
AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate,
SourceAuthenticationRequired = false,
NonInteractive = nonInteractive
};
var rootHandler = HttpClientProvider.CreateHttpMessageHandler(sourceUri, settings);
// HTTP handler pipeline can be injected here, around the client handler
HttpMessageHandler messageHandler = new MonoDevelopServerWarningLogHandler(rootHandler);
var innerHandler = messageHandler;
messageHandler = new StsAuthenticationHandler(packageSource, TokenStore.Instance)
{
InnerHandler = messageHandler
};
innerHandler = messageHandler;
var credentialsHandler = GetHttpCredentialsHandler(rootHandler);
messageHandler = new NuGetHttpSourceAuthenticationHandler(packageSource, credentialsHandler, credentialService)
{
InnerHandler = innerHandler
};
// Have to pass a dummy HttpClientProvider since it may not be used by a native implementation, such as on the Mac.
// It looks like the only place this is used in NuGet is with the DownloadResourcePluginProvider in order to pass the
// HttpClientHandler's Proxy to the GetCredentialsRequestHandler. There is no plugin support yet in MonoDevelop but
// this may be a problem in the future. Possibly a custom DownloadResourcePluginProvider would be required or possibly
// a HttpClientProvider created with just its Proxy property set based on the current proxy for that url.
var clientHandler = GetOrCreateHttpClientHandler(rootHandler);
// Get the proxy from NuGet's ProxyCache which has support for proxy information define in the NuGet.Config file.
var proxy = ProxyCache.Instance.GetUserConfiguredProxy();
if (proxy != null)
{
clientHandler.Proxy = proxy;
}
var resource = new HttpHandlerResourceV3(clientHandler, messageHandler);
return(resource);
}
private HttpHandlerResourceV3 CreateResource(PackageSource packageSource)
{
var sourceUri = packageSource.SourceUri;
var proxy = ProxyCache.Instance.GetProxy(sourceUri);
// replace the handler with the proxy aware handler
var clientHandler = new HttpClientHandler
{
Proxy = proxy,
AutomaticDecompression = (DecompressionMethods.GZip | DecompressionMethods.Deflate)
};
// HTTP handler pipeline can be injected here, around the client handler
HttpMessageHandler messageHandler = new ProgressHttpMessageHandler(clientHandler, _progressAction);
if (proxy != null)
{
messageHandler = new ProxyAuthenticationHandler(clientHandler, HttpHandlerResourceV3.CredentialService.Value, ProxyCache.Instance);
}
{
//var innerHandler = messageHandler;
// TODO: Investigate what changed in this type
// messageHandler = new StsAuthenticationHandler(packageSource, TokenStore.Instance)
// {
// InnerHandler = innerHandler
// };
}
{
var innerHandler = messageHandler;
messageHandler = new HttpSourceAuthenticationHandler(packageSource, clientHandler, HttpHandlerResourceV3.CredentialService.Value)
{
InnerHandler = innerHandler
};
}
var resource = new HttpHandlerResourceV3(clientHandler, messageHandler);
return(resource);
}
public async Task HttpSource_TimesOutDownload()
{
// Arrange
using (var td = TestDirectory.Create())
{
var expectedMilliseconds = 250;
var server = new TcpListenerServer
{
Mode = TestServerMode.SlowResponseBody,
SleepDuration = TimeSpan.FromSeconds(10)
};
var packageSource = new PackageSource(FakeSource);
var handler = new HttpClientHandler();
var handlerResource = new HttpHandlerResourceV3(handler, handler);
var httpSource = new HttpSource(
packageSource,
() => Task.FromResult((HttpHandlerResource)handlerResource),
NullThrottle.Instance)
{
HttpCacheDirectory = td
};
var logger = new TestLogger();
// Act & Assert
var actual = await Assert.ThrowsAsync <IOException>(() =>
server.ExecuteAsync(uri => httpSource.GetJObjectAsync(
new HttpSourceRequest(uri, logger)
{
DownloadTimeout = TimeSpan.FromMilliseconds(expectedMilliseconds)
},
logger,
CancellationToken.None)));
Assert.IsType <TimeoutException>(actual.InnerException);
Assert.EndsWith(
$"timed out because no data was received for {expectedMilliseconds}ms.",
actual.Message);
}
}
public override Task <Tuple <bool, INuGetResource> > TryCreate(SourceRepository source, CancellationToken token)
{
HttpHandlerResourceV3 curResource = null;
if (source.PackageSource.IsHttp)
{
var clientHandler = new HttpClientHandler();
try
{
clientHandler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
}
catch (PlatformNotSupportedException)
{
// Assume the platform is handling the decompression.
}
var messageHandler = new ServerWarningLogHandler(clientHandler);
curResource = new HttpHandlerResourceV3(clientHandler, messageHandler);
}
return(Task.FromResult(new Tuple <bool, INuGetResource>(curResource != null, curResource)));
}
static HttpMessageHandler CreateHttpMessageHandler(PackageSource packageSource, ICredentialService credentialService)
{
HttpHandlerResourceV3 resource = MonoDevelopHttpHandlerResourceV3Provider.CreateResource(packageSource, credentialService, nonInteractive: true);
return(resource.MessageHandler);
}
public CredentialsToken(HttpHandlerResourceV3 httpHandler)
{
_repositoryHttpHandler = httpHandler;
}
