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); }