public void Constructor_ThrowsForNullDispatcher()
{
using (var cancellationTokenSource = new CancellationTokenSource())
{
var exception = Assert.Throws <ArgumentNullException>(
() => new Connection(
dispatcher: null,
sender: new Sender(TextWriter.Null),
receiver: new StandardInputReceiver(TextReader.Null),
options: ConnectionOptions.CreateDefault()));
Assert.Equal("dispatcher", exception.ParamName);
}
}
public async Task GetOrCreateAsync_ThrowsForNullOrEmptyFilePath(string filePath)
{
var factory = new PluginFactory(Timeout.InfiniteTimeSpan);
var exception = await Assert.ThrowsAsync <ArgumentException>(
() => factory.GetOrCreateAsync(
filePath,
PluginConstants.PluginArguments,
new RequestHandlers(),
ConnectionOptions.CreateDefault(),
CancellationToken.None));
Assert.Equal("filePath", exception.ParamName);
}
public async Task GetOrCreateAsync_ThrowsForNullRequestHandlers()
{
var factory = new PluginFactory(Timeout.InfiniteTimeSpan);
var exception = await Assert.ThrowsAsync <ArgumentNullException>(
() => factory.GetOrCreateAsync(
filePath: "a",
arguments: PluginConstants.PluginArguments,
requestHandlers: null,
options: ConnectionOptions.CreateDefault(),
sessionCancellationToken: CancellationToken.None));
Assert.Equal("requestHandlers", exception.ParamName);
}
public async Task SendRequestAndReceiveResponseAsync_ThrowsIfCancelled()
{
using (var test = new ConnectAsyncTest(ConnectionOptions.CreateDefault(), ConnectionOptions.CreateDefault()))
{
await Task.WhenAll(
test.RemoteToLocalConnection.ConnectAsync(test.CancellationToken),
test.LocalToRemoteConnection.ConnectAsync(test.CancellationToken));
await Assert.ThrowsAsync <OperationCanceledException>(
() => test.LocalToRemoteConnection.SendRequestAndReceiveResponseAsync <LogRequest, LogResponse>(
MessageMethod.Log,
new LogRequest(LogLevel.Debug, "a"),
new CancellationToken(canceled: true)));
}
}
public void Constructor_InitializesProperties()
{
var dispatcher = Mock.Of <IMessageDispatcher>();
var sender = Mock.Of <ISender>();
var receiver = Mock.Of <IReceiver>();
var options = ConnectionOptions.CreateDefault();
using (var connection = new Connection(dispatcher, sender, receiver, options))
{
Assert.Same(dispatcher, connection.MessageDispatcher);
Assert.Same(options, connection.Options);
Assert.Null(connection.ProtocolVersion);
Assert.Equal(ConnectionState.ReadyToConnect, connection.State);
}
}
public async Task GetOrCreateAsync_WhenPluginCausesProtocolException_Throws()
{
using (var cancellationTokenSource = new CancellationTokenSource(TestTimeout))
using (var pluginFactory = new PluginFactory(PluginConstants.IdleTimeout))
{
var exception = await Assert.ThrowsAsync <ProtocolException>(() => pluginFactory.GetOrCreateAsync(
PluginFile.FullName,
PluginConstants.PluginArguments.Concat(new[] { "-CauseProtocolException" }),
new RequestHandlers(),
ConnectionOptions.CreateDefault(),
cancellationTokenSource.Token));
Assert.Equal("Plugin 'Plugin.Testable' failed with the exception: The plugin handshake failed.", exception.Message);
}
}
public async Task Close_SetsStateToClosed()
{
using (var test = new ConnectAsyncTest(ConnectionOptions.CreateDefault(), ConnectionOptions.CreateDefault()))
{
await Task.WhenAll(
test.RemoteToLocalConnection.ConnectAsync(test.CancellationToken),
test.LocalToRemoteConnection.ConnectAsync(test.CancellationToken));
Assert.Equal(ConnectionState.Connected, test.LocalToRemoteConnection.State);
test.LocalToRemoteConnection.Close();
Assert.Equal(ConnectionState.Closed, test.LocalToRemoteConnection.State);
}
}
internal static async Task <PluginTest> CreateAsync()
{
var cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromMinutes(10));
var pluginFactory = new PluginFactory(PluginConstants.IdleTimeout);
var options = ConnectionOptions.CreateDefault();
var plugin = await pluginFactory.GetOrCreateAsync(
PluginFile.FullName,
PluginArguments,
new RequestHandlers(),
options,
cancellationTokenSource.Token);
var responseSender = new ResponseSender(PortNumber);
return(new PluginTest(pluginFactory, plugin, responseSender, cancellationTokenSource));
}
public async Task GetOrCreateAsync_ThrowsIfDisposed()
{
var factory = new PluginFactory(Timeout.InfiniteTimeSpan);
factory.Dispose();
var exception = await Assert.ThrowsAsync <ObjectDisposedException>(
() => factory.GetOrCreateAsync(
filePath: "a",
arguments: PluginConstants.PluginArguments,
requestHandlers: new RequestHandlers(),
options: ConnectionOptions.CreateDefault(),
sessionCancellationToken: CancellationToken.None));
Assert.Equal(nameof(PluginFactory), exception.ObjectName);
}
public void TryCreate_SetsProxyCredentials()
{
var uri = new Uri("https://api.nuget.org/v3/index.json");
var authUsername = "******";
var authPassword = "******";
var proxyUsername = "******";
var proxyPassword = "******";
var expectation = new TestExpectation(
serviceIndexJson: null,
sourceUri: null,
operationClaims: new[] { OperationClaim.Authentication },
connectionOptions: ConnectionOptions.CreateDefault(),
pluginVersion: ProtocolConstants.CurrentVersion,
uri: uri,
authenticationUsername: authUsername,
authenticationPassword: authPassword,
success: true,
proxyUsername: proxyUsername,
proxyPassword: proxyPassword
);
using (var test = new PluginManagerMock(
pluginFilePath: "a",
pluginFileState: PluginFileState.Valid,
expectations: expectation))
{
var discoveryResult = new PluginDiscoveryResult(new PluginFile("a", new Lazy <PluginFileState>(() => PluginFileState.Valid)));
var provider = new SecurePluginCredentialProvider(test.PluginManager, discoveryResult, NullLogger.Instance);
var proxy = new System.Net.WebProxy()
{
Credentials = new NetworkCredential(proxyUsername, proxyPassword)
};
var credType = CredentialRequestType.Unauthorized;
var message = "nothing";
var isRetry = false;
var isInteractive = false;
var token = CancellationToken.None;
var credentialResponse = provider.GetAsync(uri, proxy, credType, message, isRetry, isInteractive, token).Result;
Assert.True(credentialResponse.Status == CredentialStatus.Success);
Assert.NotNull(credentialResponse.Credentials);
Assert.Equal(authUsername, credentialResponse.Credentials.GetCredential(uri, null).UserName);
Assert.Equal(authPassword, credentialResponse.Credentials.GetCredential(uri, null).Password);
}
}
internal async Task StartAsync(CancellationToken cancellationToken)
{
_cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
CancellationToken = _cancellationTokenSource.Token;
var requestHandlers = CreateRequestHandlers();
var options = ConnectionOptions.CreateDefault();
_plugin = await PluginFactory.CreateFromCurrentProcessAsync(requestHandlers, options, CancellationToken);
if (_plugin.Connection.ProtocolVersion != ProtocolConstants.CurrentVersion)
{
throw new NotSupportedException();
}
await Task.Delay(Timeout.InfiniteTimeSpan, CancellationToken);
}
public async Task OnMessageReceived_DoesNotThrowForResponseAfterWaitForResponseIsCancelled()
{
using (var dispatcher = new MessageDispatcher(new RequestHandlers(), _idGenerator))
using (var cancellationTokenSource = new CancellationTokenSource())
using (var sentEvent = new ManualResetEventSlim(initialState: false))
{
var connection = new Mock <IConnection>(MockBehavior.Strict);
connection.SetupGet(x => x.Options)
.Returns(ConnectionOptions.CreateDefault());
connection.Setup(x => x.SendAsync(It.IsNotNull <Message>(), It.IsAny <CancellationToken>()))
.Callback <Message, CancellationToken>(
(message, cancellationToken) =>
{
sentEvent.Set();
})
.Returns(Task.FromResult(0));
dispatcher.SetConnection(connection.Object);
var outboundRequestTask = Task.Run(() => dispatcher.DispatchRequestAsync <PrefetchPackageRequest, PrefetchPackageResponse>(
MessageMethod.PrefetchPackage,
new PrefetchPackageRequest(
packageSourceRepository: "a",
packageId: "b",
packageVersion: "c"),
cancellationTokenSource.Token));
sentEvent.Wait();
cancellationTokenSource.Cancel();
await Assert.ThrowsAsync <TaskCanceledException>(() => outboundRequestTask);
var response = MessageUtilities.Create(
_idGenerator.Id,
MessageType.Response,
MessageMethod.PrefetchPackage,
new PrefetchPackageResponse(MessageResponseCode.Success));
connection.Raise(x => x.MessageReceived += null, new MessageEventArgs(response));
}
}
public async Task GetOrCreateAsync_WhenPluginFreezes_Throws()
{
using (var cancellationTokenSource = new CancellationTokenSource(TestTimeout))
using (var pluginFactory = new PluginFactory(PluginConstants.IdleTimeout))
{
var exception = await Assert.ThrowsAsync <PluginException>(() => pluginFactory.GetOrCreateAsync(
PluginFile.FullName,
PluginConstants.PluginArguments.Concat(new[] { "-Freeze" }),
new RequestHandlers(),
ConnectionOptions.CreateDefault(),
cancellationTokenSource.Token));
Assert.True(
Regex.IsMatch(
exception.Message,
"^Plugin 'Plugin.Testable' failed within \\d.\\d{3} seconds with exit code -1.$"),
exception.Message);
}
}
public void TryCreate_DoesNotCreateNonCredentialsPluginTwice()
{
var uri = new Uri("https://api.nuget.org/v3/index.json");
var authUsername = "******";
var authPassword = "******";
var expectation = new TestExpectation(
serviceIndexJson: null,
sourceUri: null,
operationClaims: new[] { OperationClaim.DownloadPackage },
connectionOptions: ConnectionOptions.CreateDefault(),
pluginVersion: ProtocolConstants.CurrentVersion,
uri: uri,
authenticationUsername: authUsername,
authenticationPassword: authPassword,
success: false
);
using (var test = new PluginManagerMock(
pluginFilePath: "a",
pluginFileState: PluginFileState.Valid,
expectations: expectation))
{
var discoveryResult = new PluginDiscoveryResult(new PluginFile("a", PluginFileState.Valid));
var provider = new SecurePluginCredentialProvider(test.PluginManager, discoveryResult, NullLogger.Instance);
System.Net.IWebProxy proxy = null;
var credType = CredentialRequestType.Unauthorized;
var message = "nothing";
var isRetry = false;
var isInteractive = false;
var token = CancellationToken.None;
var credentialResponse = provider.GetAsync(uri, proxy, credType, message, isRetry, isInteractive, token).Result;
Assert.True(credentialResponse.Status == CredentialStatus.ProviderNotApplicable);
Assert.Null(credentialResponse.Credentials);
var credentialResponse2 = provider.GetAsync(uri, proxy, credType, message, isRetry, isInteractive, token).Result;
Assert.True(credentialResponse2.Status == CredentialStatus.ProviderNotApplicable);
Assert.Null(credentialResponse2.Credentials);
}
}
internal MockConnectionTest()
{
Dispatcher = new Mock <IMessageDispatcher>(MockBehavior.Strict);
Sender = new Mock <ISender>(MockBehavior.Strict);
Receiver = new Mock <IReceiver>(MockBehavior.Strict);
Dispatcher.Setup(x => x.SetConnection(It.IsNotNull <IConnection>()));
Dispatcher.Setup(x => x.Close());
Dispatcher.Setup(x => x.Dispose());
Sender.Setup(x => x.Close());
Sender.Setup(x => x.Dispose());
Receiver.Setup(x => x.Close());
Receiver.Setup(x => x.Dispose());
Connection = new Connection(
Dispatcher.Object,
Sender.Object,
Receiver.Object,
ConnectionOptions.CreateDefault());
}
public async Task Faulted_RaisedForProtocolError()
{
using (var test = new ConnectAsyncTest(ConnectionOptions.CreateDefault(), ConnectionOptions.CreateDefault()))
{
await Task.WhenAll(
test.RemoteToLocalConnection.ConnectAsync(test.CancellationToken),
test.LocalToRemoteConnection.ConnectAsync(test.CancellationToken));
using (var faultedEvent = new ManualResetEventSlim(initialState: false))
{
ProtocolErrorEventArgs args = null;
test.LocalToRemoteConnection.Faulted += (object sender, ProtocolErrorEventArgs e) =>
{
args = e;
faultedEvent.Set();
};
test.LocalToRemoteConnection.MessageDispatcher.RequestHandlers.TryAdd(
MessageMethod.Initialize,
new RequestHandler <InitializeResponse>(new InitializeResponse(MessageResponseCode.Success)));
var message = new Message(
requestId: "a",
type: MessageType.Response,
method: MessageMethod.Initialize);
await test.RemoteToLocalConnection.SendAsync(message, test.CancellationToken);
faultedEvent.Wait();
Assert.NotNull(args);
Assert.IsType <ProtocolException>(args.Exception);
Assert.NotNull(args.Message);
Assert.Equal(message.RequestId, args.Message.RequestId);
Assert.Equal(message.Type, args.Message.Type);
Assert.Equal(message.Method, args.Message.Method);
}
}
}
public async Task GetAsync_WhenProxyIsUsed_SetsProxyCredentials()
{
var proxyUsername = "******";
var proxyPassword = "******";
var expectation = new TestExpectation(
operationClaims: new[] { OperationClaim.Authentication },
connectionOptions: ConnectionOptions.CreateDefault(),
pluginVersion: ProtocolConstants.CurrentVersion,
uri: _uri,
authenticationUsername: _username,
authenticationPassword: _password,
success: true,
proxyUsername: proxyUsername,
proxyPassword: proxyPassword);
using (var test = new PluginManagerMock(
pluginFilePath: "a",
pluginFileState: PluginFileState.Valid,
expectations: expectation))
{
var discoveryResult = new PluginDiscoveryResult(new PluginFile("a", new Lazy <PluginFileState>(() => PluginFileState.Valid)));
var provider = new SecurePluginCredentialProvider(test.PluginManager, discoveryResult, canShowDialog: true, logger: NullLogger.Instance);
var proxy = new System.Net.WebProxy()
{
Credentials = new NetworkCredential(proxyUsername, proxyPassword)
};
var credType = CredentialRequestType.Unauthorized;
var message = "nothing";
var isRetry = false;
var isInteractive = false;
var token = CancellationToken.None;
var credentialResponse = await provider.GetAsync(_uri, proxy, credType, message, isRetry, isInteractive, token);
Assert.True(credentialResponse.Status == CredentialStatus.Success);
Assert.NotNull(credentialResponse.Credentials);
Assert.Equal(_username, credentialResponse.Credentials.GetCredential(_uri, authType: null).UserName);
Assert.Equal(_password, credentialResponse.Credentials.GetCredential(_uri, authType: null).Password);
}
}
public void OnMessageReceived_CancelRequestIgnoredIfNoActiveRequest()
{
using (var dispatcher = new MessageDispatcher(new RequestHandlers(), _idGenerator))
using (var handlingEvent = new ManualResetEventSlim(initialState: false))
using (var cancelEvent = new ManualResetEventSlim(initialState: false))
using (var sentEvent = new ManualResetEventSlim(initialState: false))
{
var cancellationRequest = MessageUtilities.Create(
_idGenerator.Id,
MessageType.Cancel,
MessageMethod.PrefetchPackage);
var connection = new Mock <IConnection>(MockBehavior.Strict);
connection.SetupGet(x => x.Options)
.Returns(ConnectionOptions.CreateDefault());
dispatcher.SetConnection(connection.Object);
connection.Raise(x => x.MessageReceived += null, new MessageEventArgs(cancellationRequest));
connection.Verify();
}
}
public async Task GetAsync_WhenCalledMultipleTimes_DoesNotCreateMultipleInstancesOfANonCredentialsPlugin()
{
var expectation = new TestExpectation(
operationClaims: new[] { OperationClaim.DownloadPackage },
connectionOptions: ConnectionOptions.CreateDefault(),
pluginVersion: ProtocolConstants.CurrentVersion,
uri: _uri,
authenticationUsername: _username,
authenticationPassword: _password,
success: false);
using (var test = new PluginManagerMock(
pluginFilePath: "a",
pluginFileState: PluginFileState.Valid,
expectations: expectation))
{
var discoveryResult = new PluginDiscoveryResult(new PluginFile("a", new Lazy <PluginFileState>(() => PluginFileState.Valid)));
var provider = new SecurePluginCredentialProvider(test.PluginManager, discoveryResult, canShowDialog: true, logger: NullLogger.Instance);
IWebProxy proxy = null;
var credType = CredentialRequestType.Unauthorized;
var message = "nothing";
var isRetry = false;
var isInteractive = false;
var token = CancellationToken.None;
var credentialResponse = await provider.GetAsync(_uri, proxy, credType, message, isRetry, isInteractive, token);
Assert.True(credentialResponse.Status == CredentialStatus.ProviderNotApplicable);
Assert.Null(credentialResponse.Credentials);
var credentialResponse2 = await provider.GetAsync(_uri, proxy, credType, message, isRetry, isInteractive, token);
Assert.True(credentialResponse2.Status == CredentialStatus.ProviderNotApplicable);
Assert.Null(credentialResponse2.Credentials);
}
}
private void Initialize(IEnvironmentVariableReader reader,
Lazy <IPluginDiscoverer> pluginDiscoverer,
Func <TimeSpan, IPluginFactory> pluginFactoryCreator)
{
EnvironmentVariableReader = reader ?? throw new ArgumentNullException(nameof(reader));
_discoverer = pluginDiscoverer ?? throw new ArgumentNullException(nameof(pluginDiscoverer));
if (pluginFactoryCreator == null)
{
throw new ArgumentNullException(nameof(pluginFactoryCreator));
}
_rawPluginPaths = reader.GetEnvironmentVariable(_pluginPathsEnvironmentVariable);
_connectionOptions = ConnectionOptions.CreateDefault(reader);
var idleTimeoutInSeconds = EnvironmentVariableReader.GetEnvironmentVariable(_idleTimeoutEnvironmentVariable);
var idleTimeout = TimeoutUtilities.GetTimeout(idleTimeoutInSeconds, PluginConstants.IdleTimeout);
_pluginFactory = pluginFactoryCreator(idleTimeout);
_pluginOperationClaims = new ConcurrentDictionary <PluginRequestKey, Lazy <Task <IReadOnlyList <OperationClaim> > > >();
_pluginUtilities = new ConcurrentDictionary <string, Lazy <IPluginMulticlientUtilities> >(
StringComparer.OrdinalIgnoreCase);
}
public void CreateDefault_HasCorrectHandshakeTimeout()
{
var options = ConnectionOptions.CreateDefault();
Assert.Equal(ProtocolConstants.HandshakeTimeout, options.HandshakeTimeout);
}
internal PluginResourceProviderPositiveTest(
string pluginFilePath,
PluginFileState pluginFileState,
IEnumerable <PositiveTestExpectation> expectations)
{
_expectations = expectations;
_pluginFilePath = pluginFilePath;
_reader = new Mock <IEnvironmentVariableReader>(MockBehavior.Strict);
_reader.Setup(x => x.GetEnvironmentVariable(
It.Is <string>(value => value == EnvironmentVariableConstants.PluginPaths)))
.Returns(pluginFilePath);
_reader.Setup(x => x.GetEnvironmentVariable(
It.Is <string>(value => value == EnvironmentVariableConstants.DesktopPluginPaths)))
.Returns((string)null);
_reader.Setup(x => x.GetEnvironmentVariable(
It.Is <string>(value => value == EnvironmentVariableConstants.CorePluginPaths)))
.Returns((string)null);
_reader.Setup(x => x.GetEnvironmentVariable(
It.Is <string>(value => value == EnvironmentVariableConstants.RequestTimeout)))
.Returns("RequestTimeout");
_reader.Setup(x => x.GetEnvironmentVariable(
It.Is <string>(value => value == EnvironmentVariableConstants.IdleTimeout)))
.Returns("IdleTimeout");
_reader.Setup(x => x.GetEnvironmentVariable(
It.Is <string>(value => value == EnvironmentVariableConstants.HandshakeTimeout)))
.Returns("HandshakeTimeout");
_pluginDiscoverer = new Mock <IPluginDiscoverer>(MockBehavior.Strict);
_pluginDiscoverer.Setup(x => x.Dispose());
_pluginDiscoverer.Setup(x => x.DiscoverAsync(It.IsAny <CancellationToken>()))
.ReturnsAsync(new[]
{
new PluginDiscoveryResult(new PluginFile(pluginFilePath, new Lazy <PluginFileState>(() => pluginFileState)))
});
_connection = new Mock <IConnection>(MockBehavior.Strict);
_connection.Setup(x => x.Dispose());
_connection.SetupGet(x => x.Options)
.Returns(ConnectionOptions.CreateDefault());
_connection.SetupGet(x => x.ProtocolVersion)
.Returns(ProtocolConstants.Version100);
_connection.Setup(x => x.SendRequestAndReceiveResponseAsync <MonitorNuGetProcessExitRequest, MonitorNuGetProcessExitResponse>(
It.Is <MessageMethod>(m => m == MessageMethod.MonitorNuGetProcessExit),
It.IsNotNull <MonitorNuGetProcessExitRequest>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(new MonitorNuGetProcessExitResponse(MessageResponseCode.Success));
_connection.Setup(x => x.SendRequestAndReceiveResponseAsync <InitializeRequest, InitializeResponse>(
It.Is <MessageMethod>(m => m == MessageMethod.Initialize),
It.IsNotNull <InitializeRequest>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(new InitializeResponse(MessageResponseCode.Success));
foreach (var expectation in expectations)
{
_connection.Setup(x => x.SendRequestAndReceiveResponseAsync <GetOperationClaimsRequest, GetOperationClaimsResponse>(
It.Is <MessageMethod>(m => m == MessageMethod.GetOperationClaims),
It.Is <GetOperationClaimsRequest>(
g => g.PackageSourceRepository == expectation.SourceRepository.PackageSource.Source),
It.IsAny <CancellationToken>()))
.ReturnsAsync(new GetOperationClaimsResponse(expectation.OperationClaims.ToArray()));
if (expectation.OperationClaims.Any())
{
_connection.Setup(x => x.SendRequestAndReceiveResponseAsync <SetCredentialsRequest, SetCredentialsResponse>(
It.Is <MessageMethod>(m => m == MessageMethod.SetCredentials),
It.Is <SetCredentialsRequest>(
g => g.PackageSourceRepository == expectation.SourceRepository.PackageSource.Source),
It.IsAny <CancellationToken>()))
.ReturnsAsync(new SetCredentialsResponse(MessageResponseCode.Success));
}
}
_plugin = new Mock <IPlugin>(MockBehavior.Strict);
_plugin.Setup(x => x.Dispose());
_plugin.SetupGet(x => x.Connection)
.Returns(_connection.Object);
_plugin.SetupGet(x => x.Id)
.Returns("id");
_factory = new Mock <IPluginFactory>(MockBehavior.Strict);
_factory.Setup(x => x.Dispose());
_factory.Setup(x => x.GetOrCreateAsync(
It.Is <string>(p => p == pluginFilePath),
It.IsNotNull <IEnumerable <string> >(),
It.IsNotNull <IRequestHandlers>(),
It.IsNotNull <ConnectionOptions>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(_plugin.Object);
_testDirectory = TestDirectory.Create();
PluginManager = new PluginManager(
_reader.Object,
new Lazy <IPluginDiscoverer>(() => _pluginDiscoverer.Object),
(TimeSpan idleTimeout) => _factory.Object,
new Lazy <string>(() => _testDirectory.Path));
Provider = new PluginResourceProvider(PluginManager);
}
public static async Task <int> Main(string[] args)
{
CancellationTokenSource tokenSource = new CancellationTokenSource();
var parsedArgs = await Args.ParseAsync <CredentialProviderArgs>(args);
var multiLogger = new MultiLogger();
var fileLogger = GetFileLogger();
if (fileLogger != null)
{
multiLogger.Add(fileLogger);
}
// Cancellation listener
Console.CancelKeyPress += (object sender, ConsoleCancelEventArgs eventArgs) =>
{
// ConsoleCancelEventArgs.Cancel defaults to false which terminates the current process.
multiLogger.Verbose(Resources.CancelMessage);
tokenSource.Cancel();
};
var authUtil = new AuthUtil(multiLogger);
var adalTokenCache = AdalTokenCacheUtils.GetAdalTokenCache(multiLogger);
var adalTokenProviderFactory = new VstsAdalTokenProviderFactory(adalTokenCache);
var bearerTokenProvidersFactory = new BearerTokenProvidersFactory(multiLogger, adalTokenProviderFactory);
var vstsSessionTokenProvider = new VstsSessionTokenFromBearerTokenProvider(authUtil, multiLogger);
List <ICredentialProvider> credentialProviders = new List <ICredentialProvider>
{
new VstsBuildTaskServiceEndpointCredentialProvider(multiLogger),
new VstsBuildTaskCredentialProvider(multiLogger),
new VstsCredentialProvider(multiLogger, authUtil, bearerTokenProvidersFactory, vstsSessionTokenProvider),
};
try
{
IRequestHandlers requestHandlers = new RequestHandlerCollection
{
{ MessageMethod.GetAuthenticationCredentials, new GetAuthenticationCredentialsRequestHandler(multiLogger, credentialProviders) },
{ MessageMethod.GetOperationClaims, new GetOperationClaimsRequestHandler(multiLogger, credentialProviders) },
{ MessageMethod.Initialize, new InitializeRequestHandler(multiLogger) },
{ MessageMethod.SetLogLevel, new SetLogLevelRequestHandler(multiLogger) },
{ MessageMethod.SetCredentials, new SetCredentialsRequestHandler(multiLogger) },
};
// Help
if (parsedArgs.Help)
{
Console.WriteLine(string.Format(Resources.CommandLineArgs, Program.Version, Environment.CommandLine));
Console.WriteLine(ArgUsage.GenerateUsageFromTemplate <CredentialProviderArgs>());
Console.WriteLine(
string.Format(
Resources.EnvironmentVariableHelp,
EnvUtil.LogPathEnvVar,
EnvUtil.SessionTokenCacheEnvVar,
EnvUtil.AuthorityEnvVar,
EnvUtil.AdalFileCacheEnvVar,
EnvUtil.PpeHostsEnvVar,
EnvUtil.SupportedHostsEnvVar,
EnvUtil.SessionTimeEnvVar,
EnvUtil.TokenTypeEnvVar,
EnvUtil.BuildTaskUriPrefixes,
EnvUtil.BuildTaskAccessToken,
EnvUtil.BuildTaskExternalEndpoints,
EnvUtil.AdalTokenCacheLocation,
EnvUtil.SessionTokenCacheLocation,
EnvUtil.WindowsIntegratedAuthenticationEnvVar,
EnvUtil.DeviceFlowTimeoutEnvVar
));
return(0);
}
// Plug-in mode
if (parsedArgs.Plugin)
{
using (IPlugin plugin = await PluginFactory.CreateFromCurrentProcessAsync(requestHandlers, ConnectionOptions.CreateDefault(), tokenSource.Token).ConfigureAwait(continueOnCapturedContext: false))
{
multiLogger.Add(new PluginConnectionLogger(plugin.Connection));
multiLogger.Verbose(Resources.RunningInPlugin);
multiLogger.Verbose(string.Format(Resources.CommandLineArgs, Program.Version, Environment.CommandLine));
await RunNuGetPluginsAsync(plugin, multiLogger, TimeSpan.FromMinutes(2), tokenSource.Token).ConfigureAwait(continueOnCapturedContext: false);
}
return(0);
}
// Stand-alone mode
if (requestHandlers.TryGet(MessageMethod.GetAuthenticationCredentials, out IRequestHandler requestHandler) && requestHandler is GetAuthenticationCredentialsRequestHandler getAuthenticationCredentialsRequestHandler)
{
multiLogger.Add(new ConsoleLogger());
multiLogger.SetLogLevel(parsedArgs.Verbosity);
multiLogger.Verbose(Resources.RunningInStandAlone);
multiLogger.Verbose(string.Format(Resources.CommandLineArgs, Program.Version, Environment.CommandLine));
if (parsedArgs.Uri == null)
{
Console.WriteLine(ArgUsage.GenerateUsageFromTemplate <CredentialProviderArgs>());
return(1);
}
GetAuthenticationCredentialsRequest request = new GetAuthenticationCredentialsRequest(parsedArgs.Uri, isRetry: parsedArgs.IsRetry, isNonInteractive: parsedArgs.NonInteractive, parsedArgs.CanShowDialog);
GetAuthenticationCredentialsResponse response = await getAuthenticationCredentialsRequestHandler.HandleRequestAsync(request).ConfigureAwait(continueOnCapturedContext: false);
multiLogger.Info($"{Resources.Username}: {response?.Username}");
multiLogger.Info($"{Resources.Password}: {(parsedArgs.RedactPassword ? Resources.Redacted : response?.Password)}");
return(0);
}
return(-1);
}
finally
{
foreach (ICredentialProvider credentialProvider in credentialProviders)
{
credentialProvider.Dispose();
}
}
}
public void OnMessageReceived_CancelRequestCancelsActiveRequest()
{
using (var dispatcher = new MessageDispatcher(new RequestHandlers(), _idGenerator))
using (var handlingEvent = new ManualResetEventSlim(initialState: false))
using (var respondingEvent = new ManualResetEventSlim(initialState: false))
using (var cancelEvent = new ManualResetEventSlim(initialState: false))
using (var sentEvent = new ManualResetEventSlim(initialState: false))
{
var requestHandler = new RequestHandler()
{
HandleResponseAsyncFunc = (conn, message, responseHandler, cancellationToken) =>
{
cancellationToken.Register(() => cancelEvent.Set());
handlingEvent.Set();
respondingEvent.Wait(cancellationToken);
return(Task.FromResult(0));
}
};
dispatcher.RequestHandlers.TryAdd(MessageMethod.PrefetchPackage, requestHandler);
var request = MessageUtilities.Create(
_idGenerator.Id,
MessageType.Request,
MessageMethod.PrefetchPackage,
new PrefetchPackageRequest(
packageSourceRepository: "a",
packageId: "b",
packageVersion: "c"));
var connection = new Mock <IConnection>(MockBehavior.Strict);
connection.SetupGet(x => x.Options)
.Returns(ConnectionOptions.CreateDefault());
connection.Setup(x => x.SendAsync(
It.Is <Message>(
m => m.RequestId == request.RequestId &&
m.Type == MessageType.Cancel &&
m.Method == request.Method &&
m.Payload == null),
It.IsAny <CancellationToken>()))
.Callback <Message, CancellationToken>(
(message, cancellationToken) =>
{
sentEvent.Set();
})
.Returns(Task.FromResult(0));
dispatcher.SetConnection(connection.Object);
connection.Raise(x => x.MessageReceived += null, new MessageEventArgs(request));
handlingEvent.Wait();
var cancellationRequest = MessageUtilities.Create(
_idGenerator.Id,
MessageType.Cancel,
MessageMethod.PrefetchPackage);
connection.Raise(x => x.MessageReceived += null, new MessageEventArgs(cancellationRequest));
cancelEvent.Wait();
sentEvent.Wait();
connection.Verify();
}
}
public ConnectionMock()
{
_event = new ManualResetEventSlim(initialState: false);
Options = ConnectionOptions.CreateDefault();
}
public static async Task <int> Main(string[] args)
{
CancellationTokenSource tokenSource = new CancellationTokenSource();
var parsedArgs = await Args.ParseAsync <CredentialProviderArgs>(args);
var multiLogger = new MultiLogger();
var fileLogger = GetFileLogger();
if (fileLogger != null)
{
multiLogger.Add(fileLogger);
}
// Cancellation listener
Console.CancelKeyPress += (object sender, ConsoleCancelEventArgs eventArgs) =>
{
// ConsoleCancelEventArgs.Cancel defaults to false which terminates the current process.
multiLogger.Verbose(Resources.CancelMessage);
tokenSource.Cancel();
};
var authUtil = new AuthUtil(multiLogger);
var adalTokenCache = AdalTokenCacheUtils.GetAdalTokenCache(multiLogger);
var adalTokenProviderFactory = new VstsAdalTokenProviderFactory(adalTokenCache);
var bearerTokenProvidersFactory = new BearerTokenProvidersFactory(multiLogger, adalTokenProviderFactory);
var vstsSessionTokenProvider = new VstsSessionTokenFromBearerTokenProvider(authUtil, multiLogger);
List <ICredentialProvider> credentialProviders = new List <ICredentialProvider>
{
new VstsBuildTaskServiceEndpointCredentialProvider(multiLogger),
new VstsBuildTaskCredentialProvider(multiLogger),
new VstsCredentialProvider(multiLogger, authUtil, bearerTokenProvidersFactory, vstsSessionTokenProvider),
};
try
{
IRequestHandlers requestHandlers = new RequestHandlerCollection
{
{ MessageMethod.GetAuthenticationCredentials, new GetAuthenticationCredentialsRequestHandler(multiLogger, credentialProviders) },
{ MessageMethod.GetOperationClaims, new GetOperationClaimsRequestHandler(multiLogger, credentialProviders) },
{ MessageMethod.Initialize, new InitializeRequestHandler(multiLogger) },
{ MessageMethod.SetLogLevel, new SetLogLevelRequestHandler(multiLogger) },
{ MessageMethod.SetCredentials, new SetCredentialsRequestHandler(multiLogger) },
};
// Help
if (parsedArgs.Help)
{
Console.WriteLine(string.Format(Resources.CommandLineArgs, Program.Version, Environment.CommandLine));
Console.WriteLine(ArgUsage.GenerateUsageFromTemplate <CredentialProviderArgs>());
Console.WriteLine(
string.Format(
Resources.EnvironmentVariableHelp,
EnvUtil.LogPathEnvVar,
EnvUtil.SessionTokenCacheEnvVar,
EnvUtil.AuthorityEnvVar,
EnvUtil.AdalFileCacheEnvVar,
EnvUtil.PpeHostsEnvVar,
EnvUtil.SupportedHostsEnvVar,
EnvUtil.SessionTimeEnvVar,
EnvUtil.TokenTypeEnvVar,
EnvUtil.BuildTaskUriPrefixes,
EnvUtil.BuildTaskAccessToken,
EnvUtil.BuildTaskExternalEndpoints,
EnvUtil.AdalTokenCacheLocation,
EnvUtil.SessionTokenCacheLocation,
EnvUtil.WindowsIntegratedAuthenticationEnvVar,
EnvUtil.DeviceFlowTimeoutEnvVar
));
return(0);
}
// Plug-in mode
if (parsedArgs.Plugin)
{
try
{
using (IPlugin plugin = await PluginFactory.CreateFromCurrentProcessAsync(requestHandlers, ConnectionOptions.CreateDefault(), tokenSource.Token).ConfigureAwait(continueOnCapturedContext: false))
{
multiLogger.Add(new PluginConnectionLogger(plugin.Connection));
multiLogger.Verbose(Resources.RunningInPlugin);
multiLogger.Verbose(string.Format(Resources.CommandLineArgs, Program.Version, Environment.CommandLine));
await WaitForPluginExitAsync(plugin, multiLogger, TimeSpan.FromMinutes(2)).ConfigureAwait(continueOnCapturedContext: false);
}
}
catch (OperationCanceledException ex)
{
// When restoring from multiple sources, one of the sources will throw an unhandled TaskCanceledException
// if it has been restored successfully from a different source.
// This is probably more confusing than interesting to users, but may be helpful in debugging,
// so log the exception but not to the console.
multiLogger.Log(LogLevel.Verbose, allowOnConsole: false, ex.ToString());
}
return(0);
}
// Stand-alone mode
if (requestHandlers.TryGet(MessageMethod.GetAuthenticationCredentials, out IRequestHandler requestHandler) && requestHandler is GetAuthenticationCredentialsRequestHandler getAuthenticationCredentialsRequestHandler)
{
// When emitting machine-readable output to standard out, logging (including Device Code prompts) must be emitted to standard error
if (parsedArgs.OutputFormat == OutputFormat.Json)
{
multiLogger.Add(new StandardErrorLogger());
}
else
{
multiLogger.Add(new StandardOutputLogger());
}
multiLogger.SetLogLevel(parsedArgs.Verbosity);
multiLogger.Verbose(Resources.RunningInStandAlone);
multiLogger.Verbose(string.Format(Resources.CommandLineArgs, Program.Version, Environment.CommandLine));
if (parsedArgs.Uri == null)
{
Console.WriteLine(ArgUsage.GenerateUsageFromTemplate <CredentialProviderArgs>());
return(1);
}
GetAuthenticationCredentialsRequest request = new GetAuthenticationCredentialsRequest(parsedArgs.Uri, isRetry: parsedArgs.IsRetry, isNonInteractive: parsedArgs.NonInteractive, parsedArgs.CanShowDialog);
GetAuthenticationCredentialsResponse response = await getAuthenticationCredentialsRequestHandler.HandleRequestAsync(request).ConfigureAwait(continueOnCapturedContext: false);
// Fail if credentials are not found
if (response?.ResponseCode != MessageResponseCode.Success)
{
return(2);
}
string resultUsername = response?.Username;
string resultPassword = parsedArgs.RedactPassword ? Resources.Redacted : response?.Password;
if (parsedArgs.OutputFormat == OutputFormat.Json)
{
// Manually write the JSON output, since we don't use ConsoleLogger in JSON mode (see above)
Console.WriteLine(JsonConvert.SerializeObject(new CredentialResult(resultUsername, resultPassword)));
}
else
{
multiLogger.Info($"{Resources.Username}: {resultUsername}");
multiLogger.Info($"{Resources.Password}: {resultPassword}");
}
return(0);
}
return(-1);
}
finally
{
foreach (ICredentialProvider credentialProvider in credentialProviders)
{
credentialProvider.Dispose();
}
}
}
public void CreateDefault_HasCorrectRequestTimeoutDefault()
{
var options = ConnectionOptions.CreateDefault();
Assert.Equal(ProtocolConstants.RequestTimeout, options.RequestTimeout);
}
public async Task ConnectAsync_HandshakeNegotiatesProtocolVersionForIdenticalVersionRanges()
{
using (var test = new ConnectAsyncTest(ConnectionOptions.CreateDefault(), ConnectionOptions.CreateDefault()))
{
await Task.WhenAll(
test.RemoteToLocalConnection.ConnectAsync(test.CancellationToken),
test.LocalToRemoteConnection.ConnectAsync(test.CancellationToken));
Assert.NotNull(test.RemoteToLocalConnection.ProtocolVersion);
Assert.NotNull(test.LocalToRemoteConnection.ProtocolVersion);
Assert.Equal(test.RemoteToLocalConnection.ProtocolVersion, test.LocalToRemoteConnection.ProtocolVersion);
}
}
public void CreateDefault_HasCorrectMinimumProtocolVersion()
{
var options = ConnectionOptions.CreateDefault();
Assert.Equal(ProtocolConstants.Version100, options.MinimumProtocolVersion);
}
public void CreateDefault_HasCorrectProtocolVersion()
{
var options = ConnectionOptions.CreateDefault();
Assert.Equal(ProtocolConstants.CurrentVersion, options.ProtocolVersion);
}
