public PostPageViewModel(IUxService uxService, INavigationService navigationService, IServiceBroker serviceBroker, IEventAggregator eventAggregator, IProgressService progressService, IWindowManager windowManager)
: base(progressService, windowManager, navigationService)
{
this._uxService = uxService;
this._serviceBroker = serviceBroker;
this.Photos = new ObservableCollection<Models.Ui.ItemWithUrl>();
}
private NuGetSearchServiceReconnector(IServiceBroker serviceBroker, JoinableTaskFactory jtf, INuGetSearchService initialService)
{
if (serviceBroker == null)
{
throw new ArgumentNullException(nameof(serviceBroker));
}
if (jtf == null)
{
throw new ArgumentNullException(nameof(jtf));
}
if (initialService == null)
{
throw new ArgumentNullException(nameof(initialService));
}
_disposedTokenSource = new CancellationTokenSource();
_jtf = jtf;
_serviceBroker = serviceBroker;
_service = initialService;
_serviceBroker.AvailabilityChanged += AvailabilityChanged;
_object = new ManagedNuGetSearchService(this);
}
internal TService Create(
IDuplexPipe pipe,
IServiceProvider hostProvidedServices,
ServiceActivationOptions serviceActivationOptions,
IServiceBroker serviceBroker
)
{
var descriptor = ServiceDescriptors.Instance.GetServiceDescriptorForServiceFactory(
typeof(TService)
);
var serviceHubTraceSource = (TraceSource)hostProvidedServices.GetService(
typeof(TraceSource)
);
var serverConnection = descriptor
.WithTraceSource(serviceHubTraceSource)
.ConstructRpcConnection(pipe);
var args = new ServiceConstructionArguments(hostProvidedServices, serviceBroker);
var service = CreateService(
args,
descriptor,
serverConnection,
serviceActivationOptions.ClientRpcTarget
);
serverConnection.AddLocalRpcTarget(service);
serverConnection.StartListening();
return(service);
}
public static async Task <string> GetEmbeddedLicenseAsync(PackageIdentity packageIdentity, CancellationToken cancellationToken)
{
string content = null;
IServiceBrokerProvider serviceBrokerProvider = await ServiceLocator.GetInstanceAsync <IServiceBrokerProvider>();
IServiceBroker serviceBroker = await serviceBrokerProvider.GetAsync();
using (INuGetPackageFileService packageFileService = await serviceBroker.GetProxyAsync <INuGetPackageFileService>(NuGetServices.PackageFileService))
{
if (packageFileService != null)
{
using (Stream stream = await packageFileService.GetEmbeddedLicenseAsync(packageIdentity, CancellationToken.None))
{
if (stream != null)
{
using (var reader = new StreamReader(stream))
{
content = reader.ReadToEnd();
}
}
}
}
}
return(content);
}
// Non-private only to facilitate testing.
internal NuGetUIContext(
IServiceBroker serviceBroker,
IReconnectingNuGetSearchService nuGetSearchService,
IVsSolutionManager solutionManager,
NuGetSolutionManagerServiceWrapper solutionManagerService,
NuGetPackageManager packageManager,
UIActionEngine uiActionEngine,
IPackageRestoreManager packageRestoreManager,
IOptionsPageActivator optionsPageActivator,
IUserSettingsManager userSettingsManager,
NuGetSourcesServiceWrapper sourceService)
{
ServiceBroker = serviceBroker;
ReconnectingSearchService = nuGetSearchService;
SolutionManager = solutionManager;
_solutionManagerService = solutionManagerService;
PackageManager = packageManager;
UIActionEngine = uiActionEngine;
PackageManager = packageManager;
PackageRestoreManager = packageRestoreManager;
OptionsPageActivator = optionsPageActivator;
UserSettingsManager = userSettingsManager;
_sourceService = sourceService;
ServiceBroker.AvailabilityChanged += OnAvailabilityChanged;
SolutionManager.ActionsExecuted += OnActionsExecuted;
}
public ServiceWorker(IServiceBroker <TNotification> broker, IServiceConnection <TNotification> connection)
{
Broker = broker;
Connection = connection;
CancelTokenSource = new CancellationTokenSource();
}
private async ValueTask InitializeAsync(
INuGetSolutionManagerService solutionManager,
IEnumerable <IVsPackageManagerProvider> packageManagerProviders,
IServiceBroker serviceBroker,
CancellationToken cancellationToken)
{
_solutionManager = solutionManager;
_solutionManager.ProjectAdded += SolutionProjectChanged;
_solutionManager.ProjectRemoved += SolutionProjectChanged;
_solutionManager.ProjectUpdated += SolutionProjectChanged;
_solutionManager.ProjectRenamed += SolutionProjectChanged;
// when the SelectedVersion is changed, we need to update CanInstall and CanUninstall.
PropertyChanged += (_, e) =>
{
if (e.PropertyName == nameof(SelectedVersion))
{
UpdateCanInstallAndCanUninstall();
}
};
_packageManagerProviders = packageManagerProviders;
await CreateProjectListsAsync(serviceBroker, cancellationToken);
}
// For unit testing purposes
internal static async ValueTask <PackageItemLoader> CreateAsync(
IServiceBroker serviceBroker,
PackageLoadContext context,
IReadOnlyCollection <PackageSourceContextInfo> packageSources,
ContractItemFilter itemFilter,
IReconnectingNuGetSearchService searchService,
INuGetPackageFileService packageFileService,
string searchText = null,
bool includePrerelease = true,
bool useRecommender = false)
{
var itemLoader = new PackageItemLoader(
serviceBroker,
searchService,
context,
packageSources,
itemFilter,
searchText,
includePrerelease,
useRecommender);
await itemLoader.InitializeAsync(packageFileService);
return(itemLoader);
}
public static async Task <InstalledAndTransitivePackageCollections> FromProjectsIncludeTransitiveAsync(
IServiceBroker serviceBroker,
IEnumerable <IProjectContextInfo> projects,
CancellationToken cancellationToken)
{
Assumes.NotNull(serviceBroker);
Assumes.NotNull(projects);
// Read installed and transitive package references from all projects.
IEnumerable <Task <IInstalledAndTransitivePackages> > tasks = projects
.Select(project => project.GetInstalledAndTransitivePackagesAsync(serviceBroker, cancellationToken).AsTask());
IInstalledAndTransitivePackages[] allPackageReferences = await Task.WhenAll(tasks);
// Group all installed package references for an id/version into a single item.
PackageCollectionItem[] installedPackages = allPackageReferences
.SelectMany(e => e.InstalledPackages)
.GroupBy(e => e.Identity, (key, group) => new PackageCollectionItem(key.Id, key.Version, group))
.ToArray();
// Group all transitive package references for an id/version into a single item.
PackageCollectionItem[] transitivePackages = allPackageReferences
.SelectMany(e => e.TransitivePackages)
.GroupBy(e => e.Identity, (key, group) => new PackageCollectionItem(key.Id, key.Version, group))
.ToArray();
return(new InstalledAndTransitivePackageCollections(new PackageCollection(installedPackages), new PackageCollection(transitivePackages)));
}
private async Task PerformActionAsync(
INuGetUI uiService,
UserAction userAction,
NuGetOperationType operationType,
ResolveActionsAsync resolveActionsAsync,
CancellationToken cancellationToken)
{
IServiceBroker serviceBroker = uiService.UIContext.ServiceBroker;
using (INuGetProjectManagerService projectManagerService = await serviceBroker.GetProxyAsync <INuGetProjectManagerService>(
NuGetServices.ProjectManagerService,
cancellationToken: cancellationToken))
{
Assumes.NotNull(projectManagerService);
await projectManagerService.BeginOperationAsync(cancellationToken);
try
{
await PerformActionImplAsync(
serviceBroker,
projectManagerService,
uiService,
resolveActionsAsync,
operationType,
userAction,
cancellationToken);
}
finally
{
await projectManagerService.EndOperationAsync(cancellationToken);
}
}
}
public static async Task <RemoteHostClient> CreateAsync(
HostWorkspaceServices services,
RemoteProcessConfiguration configuration,
AsynchronousOperationListenerProvider listenerProvider,
IServiceBroker serviceBroker,
RemoteServiceCallbackDispatcherRegistry callbackDispatchers,
CancellationToken cancellationToken)
{
using (Logger.LogBlock(FunctionId.ServiceHubRemoteHostClient_CreateAsync, KeyValueLogMessage.NoProperty, cancellationToken))
{
#pragma warning disable ISB001 // Dispose of proxies
#pragma warning disable VSTHRD012 // Provide JoinableTaskFactory where allowed
var serviceBrokerClient = new ServiceBrokerClient(serviceBroker);
#pragma warning restore
var hubClient = new HubClient("ManagedLanguage.IDE.RemoteHostClient");
var client = new ServiceHubRemoteHostClient(services, configuration, serviceBrokerClient, hubClient, callbackDispatchers);
var syntaxTreeConfigurationService = services.GetService <ISyntaxTreeConfigurationService>();
if (syntaxTreeConfigurationService != null)
{
await client.TryInvokeAsync <IRemoteProcessTelemetryService>(
(service, cancellationToken) => service.SetSyntaxTreeConfigurationOptionsAsync(syntaxTreeConfigurationService.DisableRecoverableTrees, syntaxTreeConfigurationService.DisableProjectCacheService, syntaxTreeConfigurationService.EnableOpeningSourceGeneratedFilesInWorkspace, cancellationToken),
cancellationToken).ConfigureAwait(false);
}
await client.TryInvokeAsync <IRemoteAsynchronousOperationListenerService>(
(service, cancellationToken) => service.EnableAsync(AsynchronousOperationListenerProvider.IsEnabled, listenerProvider.DiagnosticTokensEnabled, cancellationToken),
cancellationToken).ConfigureAwait(false);
client.Started();
return(client);
}
}
public async Task UpgradeProjectsToPackageReferenceAsync(IEnumerable <IProjectContextInfo> msBuildProjects)
{
if (msBuildProjects == null)
{
throw new ArgumentNullException(nameof(msBuildProjects));
}
List <IProjectContextInfo> projects = Projects.ToList();
IServiceBroker serviceBroker = await BrokeredServicesUtilities.GetRemoteServiceBrokerAsync();
using (INuGetProjectUpgraderService projectUpgrader = await serviceBroker.GetProxyAsync <INuGetProjectUpgraderService>(
NuGetServices.ProjectUpgraderService,
cancellationToken: CancellationToken.None))
{
Assumes.NotNull(projectUpgrader);
foreach (IProjectContextInfo project in msBuildProjects)
{
IProjectContextInfo newProject = await projectUpgrader.UpgradeProjectToPackageReferenceAsync(
project.ProjectId,
CancellationToken.None);
if (newProject != null)
{
projects.Remove(project);
projects.Add(newProject);
}
}
}
Projects = projects;
}
// Non-private only to facilitate testing.
internal NuGetUIContext(
IServiceBroker serviceBroker,
IVsSolutionManager solutionManager,
NuGetSolutionManagerServiceWrapper solutionManagerService,
NuGetPackageManager packageManager,
UIActionEngine uiActionEngine,
IPackageRestoreManager packageRestoreManager,
IOptionsPageActivator optionsPageActivator,
IUserSettingsManager userSettingsManager,
IEnumerable <IVsPackageManagerProvider> packageManagerProviders,
NuGetSourcesServiceWrapper sourceService)
{
ServiceBroker = serviceBroker;
SolutionManager = solutionManager;
_solutionManagerService = solutionManagerService;
PackageManager = packageManager;
UIActionEngine = uiActionEngine;
PackageManager = packageManager;
PackageRestoreManager = packageRestoreManager;
OptionsPageActivator = optionsPageActivator;
UserSettingsManager = userSettingsManager;
PackageManagerProviders = packageManagerProviders;
_sourceService = sourceService;
ServiceBroker.AvailabilityChanged += OnAvailabilityChanged;
SolutionManager.ActionsExecuted += OnActionsExecuted;
}
private ServiceHubRemoteHostClient(
HostWorkspaceServices services,
IServiceBroker serviceBroker,
ServiceBrokerClient serviceBrokerClient,
HubClient hubClient,
Stream stream)
{
_connectionPools = new ConnectionPools(
connectionFactory: (serviceName, pool, cancellationToken) => CreateConnectionImplAsync(serviceName, callbackTarget: null, pool, cancellationToken),
capacity: ConnectionPoolCapacity);
// use the hub client logger for unexpected exceptions from devenv as well, so we have complete information in the log:
services.GetService <IWorkspaceTelemetryService>()?.RegisterUnexpectedExceptionLogger(hubClient.Logger);
_services = services;
_serviceBroker = serviceBroker;
_serviceBrokerClient = serviceBrokerClient;
_hubClient = hubClient;
_endPoint = new RemoteEndPoint(stream, hubClient.Logger, incomingCallTarget: this);
_endPoint.Disconnected += OnDisconnected;
_endPoint.UnexpectedExceptionThrown += OnUnexpectedExceptionThrown;
_endPoint.StartListening();
_assetStorage = services.GetRequiredService <ISolutionAssetStorageProvider>().AssetStorage;
_serializer = services.GetRequiredService <ISerializerService>();
_errorReportingService = services.GetService <IErrorReportingService>();
_shutdownCancellationService = services.GetService <IRemoteHostClientShutdownCancellationService>();
}
private List <PackageInstallationInfo> _projects; // List of projects in the solution
private PackageSolutionDetailControlModel(
IServiceBroker serviceBroker,
IEnumerable <IProjectContextInfo> projects)
: base(serviceBroker, projects)
{
IsRequestedVisible = projects.Any(p => p.ProjectStyle == ProjectStyle.PackageReference);
}
public ServiceConstructionArguments(
IServiceProvider serviceProvider,
IServiceBroker serviceBroker
)
{
ServiceProvider = serviceProvider;
ServiceBroker = serviceBroker;
}
public RazorServiceBase(IServiceBroker serviceBroker)
{
RazorServices = new RazorServices();
#pragma warning disable VSTHRD012 // Provide JoinableTaskFactory where allowed
ServiceBrokerClient = new ServiceBrokerClient(serviceBroker);
#pragma warning restore
}
public NuGetPackageFileService(IServiceBroker serviceBroker, INuGetTelemetryProvider nuGetTelemetryProvider)
{
_serviceBroker = serviceBroker;
Assumes.NotNull(_serviceBroker);
_nuGetTelemetryProvider = nuGetTelemetryProvider;
Assumes.NotNull(_nuGetTelemetryProvider);
}
public static async ValueTask <NuGetUIContext> CreateAsync(
IServiceBroker serviceBroker,
ISourceRepositoryProvider sourceRepositoryProvider,
ISettings settings,
IVsSolutionManager solutionManager,
IPackageRestoreManager packageRestoreManager,
IOptionsPageActivator optionsPageActivator,
IUserSettingsManager userSettingsManager,
IDeleteOnRestartManager deleteOnRestartManager,
IEnumerable <IVsPackageManagerProvider> packageManagerProviders,
INuGetLockService lockService,
CancellationToken cancellationToken)
{
Assumes.NotNull(serviceBroker);
Assumes.NotNull(sourceRepositoryProvider);
Assumes.NotNull(settings);
Assumes.NotNull(solutionManager);
Assumes.NotNull(packageRestoreManager);
Assumes.NotNull(optionsPageActivator);
Assumes.NotNull(userSettingsManager);
Assumes.NotNull(deleteOnRestartManager);
Assumes.NotNull(packageManagerProviders);
Assumes.NotNull(lockService);
cancellationToken.ThrowIfCancellationRequested();
var solutionManagerServiceWrapper = new NuGetSolutionManagerServiceWrapper();
INuGetSolutionManagerService solutionManagerService = await GetSolutionManagerServiceAsync(serviceBroker, cancellationToken);
// The initial Swap(...) should return a null implementation of the interface that does not require disposal.
// However, there's no harm in following form.
using (solutionManagerServiceWrapper.Swap(solutionManagerService))
{
}
var packageManager = new NuGetPackageManager(
sourceRepositoryProvider,
settings,
solutionManager,
deleteOnRestartManager);
var actionEngine = new UIActionEngine(
sourceRepositoryProvider,
packageManager,
lockService);
return(new NuGetUIContext(
sourceRepositoryProvider,
serviceBroker,
solutionManager,
solutionManagerServiceWrapper,
packageManager,
actionEngine,
packageRestoreManager,
optionsPageActivator,
userSettingsManager,
packageManagerProviders));
}
public static async Task <NuGetUI> CreateAsync(
IServiceBroker serviceBroker,
ICommonOperations commonOperations,
NuGetUIProjectContext projectContext,
ISourceRepositoryProvider sourceRepositoryProvider,
ISettings settings,
IVsSolutionManager solutionManager,
IPackageRestoreManager packageRestoreManager,
IOptionsPageActivator optionsPageActivator,
IUserSettingsManager userSettingsManager,
IDeleteOnRestartManager deleteOnRestartManager,
SolutionUserOptions solutionUserOptions,
INuGetLockService lockService,
INuGetUILogger logger,
IRestoreProgressReporter restoreProgressReporter,
CancellationToken cancellationToken,
params IProjectContextInfo[] projects)
{
Assumes.NotNull(serviceBroker);
Assumes.NotNull(commonOperations);
Assumes.NotNull(projectContext);
Assumes.NotNull(sourceRepositoryProvider);
Assumes.NotNull(settings);
Assumes.NotNull(solutionManager);
Assumes.NotNull(packageRestoreManager);
Assumes.NotNull(optionsPageActivator);
Assumes.NotNull(userSettingsManager);
Assumes.NotNull(deleteOnRestartManager);
Assumes.NotNull(solutionUserOptions);
Assumes.NotNull(lockService);
Assumes.NotNull(restoreProgressReporter);
Assumes.NotNull(logger);
cancellationToken.ThrowIfCancellationRequested();
var nuGetUi = new NuGetUI(
commonOperations,
projectContext,
logger)
{
UIContext = await NuGetUIContext.CreateAsync(
serviceBroker,
sourceRepositoryProvider,
settings,
solutionManager,
packageRestoreManager,
optionsPageActivator,
solutionUserOptions,
deleteOnRestartManager,
lockService,
restoreProgressReporter,
cancellationToken)
};
nuGetUi.UIContext.Projects = projects;
return(nuGetUi);
}
public static async ValueTask <string?> GetUniqueNameOrNameAsync(
this IProjectContextInfo projectContextInfo,
IServiceBroker serviceBroker,
CancellationToken cancellationToken)
{
IProjectMetadataContextInfo metadata = await GetMetadataAsync(projectContextInfo, serviceBroker, cancellationToken);
return(metadata.UniqueName ?? metadata.Name);
}
public static async Task <IProjectContextInfo> CreateAsync(IServiceBroker serviceBroker, string projectId, CancellationToken cancellationToken)
{
using (INuGetProjectManagerService projectManager = await serviceBroker.GetProxyAsync <INuGetProjectManagerService>(
NuGetServices.ProjectManagerService,
CancellationToken.None))
{
return(await projectManager.GetProjectAsync(projectId, cancellationToken));
}
}
public PackageDetailControlModel(
IServiceBroker serviceBroker,
INuGetSolutionManagerService solutionManager,
IEnumerable <IProjectContextInfo> projects)
: base(serviceBroker, projects)
{
_solutionManager = solutionManager;
_solutionManager.ProjectUpdated += ProjectChanged;
}
public async Task GetAsync_Always_IsIdempotent()
{
var provider = new CachingIServiceBrokerProvider();
IServiceBroker serviceBroker1 = await provider.GetAsync();
IServiceBroker serviceBroker2 = await provider.GetAsync();
Assert.Same(serviceBroker1, serviceBroker2);
}
public StockService(IOptions <AppSettings> appSettings,
IMessageService messageService,
IServiceBroker serviceBroker
)
{
settings = appSettings.Value;
_client = new HttpClient();
_messageService = messageService;
_serviceBroker = serviceBroker;
}
public static IServiceCollection RegisterServiceBroker(IServiceCollection services,
IServiceBroker serviceBroker, Action <IServiceRegistrationOptions> configure)
{
var serviceRegistrationOptions = new DefaultServiceRegistrationOptions();
configure(serviceRegistrationOptions);
serviceBroker.RegisterServicesFromAssemblies(services, serviceRegistrationOptions);
return(services);
}
public static async ValueTask <PackageInstallationInfo> CreateAsync(
IServiceBroker serviceBroker,
IProjectContextInfo project,
CancellationToken cancellationToken)
{
var packageInstallationInfo = new PackageInstallationInfo(serviceBroker, project);
await packageInstallationInfo.InitializeAsync(cancellationToken);
return(packageInstallationInfo);
}
internal static async ValueTask <PackageSolutionDetailControlModel> CreateAsync(
INuGetSolutionManagerService solutionManager,
IEnumerable <IProjectContextInfo> projects,
IServiceBroker serviceBroker,
CancellationToken cancellationToken)
{
var packageSolutionDetailControlModel = new PackageSolutionDetailControlModel(serviceBroker, projects);
await packageSolutionDetailControlModel.InitializeAsync(solutionManager, cancellationToken);
return(packageSolutionDetailControlModel);
}
internal TService Create(IDuplexPipe pipe, IServiceBroker serviceBroker)
{
var descriptor = _razorServiceDescriptors.GetDescriptorForServiceFactory(typeof(TService));
var serverConnection = descriptor.ConstructRpcConnection(pipe);
var service = CreateService(serviceBroker);
serverConnection.AddLocalRpcTarget(service);
serverConnection.StartListening();
return(service);
}
public Task <object> CreateAsync(
Stream stream,
IServiceProvider hostProvidedServices,
ServiceActivationOptions serviceActivationOptions,
IServiceBroker serviceBroker,
AuthorizationServiceClient?authorizationServiceClient)
{
// Dispose the AuthorizationServiceClient since we won't be using it
authorizationServiceClient?.Dispose();
return(Task.FromResult((object)Create(stream.UsePipe(), serviceBroker)));
}
public CommunicationService(IMessageService messageService,
IHubContext <ChatHub, IClient> hubContext,
ICommandHelper commandHelper,
IServiceBroker serviceBroker,
IStockService stockService)
{
_messageService = messageService;
_chatHub = hubContext;
_commandHelper = commandHelper;
_serviceBroker = serviceBroker;
_stockService = stockService;
}
public CategoriesPageViewModel(INavigationService navigationService,
IEventAggregator eventAggregator,
IServiceBroker serviceBroker,
IProgressService progressService,
IWindowManager windowManager)
{
this._serviceBroker = serviceBroker;
this._navigationService = navigationService;
this._eventAggregator = eventAggregator;
this._progressService = progressService;
this._windowManager = windowManager;
this.Items = new ObservableCollection<Models.Ui.HomeItem>();
}
public MainPageViewModel(IUxService uxService, INavigationService navigationService, IEventAggregator eventAggregator, IServiceBroker serviceBroker, IProgressService progressService, IWindowManager windowManager)
: base(progressService, windowManager, navigationService)
{
this.serviceBroker = serviceBroker;
this._uxService = uxService;
}
public DefaultController(IServiceBroker broker)
{
this.broker = broker;
}
public MessageQueueWorker(MessageHub hub, IServiceBroker broker)
{
this.hub = hub;
this.broker = broker;
}
