public ConnectionManager(IStatusBar statusBar, IRSettings settings, IRInteractiveWorkflow interactiveWorkflow) {
_statusBar = statusBar;
_sessionProvider = interactiveWorkflow.RSessions;
_settings = settings;
_interactiveWorkflow = interactiveWorkflow;
_shell = interactiveWorkflow.Shell;
_securityService = _shell.Services.Security;
_statusBarViewModel = new ConnectionStatusBarViewModel(this, interactiveWorkflow.Shell);
_hostLoadIndicatorViewModel = new HostLoadIndicatorViewModel(_sessionProvider, interactiveWorkflow.Shell);
_disposableBag = DisposableBag.Create<ConnectionManager>()
.Add(_statusBarViewModel)
.Add(_hostLoadIndicatorViewModel)
.Add(() => _sessionProvider.BrokerStateChanged -= BrokerStateChanged)
.Add(() => _interactiveWorkflow.ActiveWindowChanged -= ActiveWindowChanged);
_sessionProvider.BrokerStateChanged += BrokerStateChanged;
_interactiveWorkflow.ActiveWindowChanged += ActiveWindowChanged;
// Get initial values
var connections = CreateConnectionList();
_connections = new ConcurrentDictionary<string, IConnection>(connections);
UpdateRecentConnections(save: false);
CompleteInitializationAsync().DoNotWait();
}
public RPlotHistoryVisualComponent(IRPlotManager plotManager, ICommandTarget controller, IVisualComponentContainer<IRPlotHistoryVisualComponent> container, ICoreShell coreShell) {
if (plotManager == null) {
throw new ArgumentNullException(nameof(plotManager));
}
if (container == null) {
throw new ArgumentNullException(nameof(container));
}
if (coreShell == null) {
throw new ArgumentNullException(nameof(coreShell));
}
_plotManager = plotManager;
_viewModel = new RPlotHistoryViewModel(plotManager, coreShell);
_shell = coreShell;
var control = new RPlotHistoryControl {
DataContext = _viewModel
};
_disposableBag = DisposableBag.Create<RPlotDeviceVisualComponent>()
.Add(() => control.ContextMenuRequested -= Control_ContextMenuRequested);
control.ContextMenuRequested += Control_ContextMenuRequested;
Control = control;
Controller = controller;
Container = container;
}
public RPlotHistoryViewModel(IRPlotManager plotManager, ICoreShell shell) {
if (plotManager == null) {
throw new ArgumentNullException(nameof(plotManager));
}
if (shell == null) {
throw new ArgumentNullException(nameof(shell));
}
_plotManager = plotManager;
_shell = shell;
_disposableBag = DisposableBag.Create<RPlotHistoryViewModel>()
.Add(() => _plotManager.DeviceAdded -= DeviceAdded)
.Add(() => _plotManager.DeviceRemoved -= DeviceRemoved);
_plotManager.DeviceAdded += DeviceAdded;
_plotManager.DeviceRemoved += DeviceRemoved;
foreach (var group in _plotManager.GetAllPlots().GroupBy(p => p.ParentDevice)) {
SubscribeDeviceEvents(group.Key);
foreach (var plot in group) {
Entries.Add(new RPlotHistoryEntryViewModel(_plotManager, _shell, plot, plot.Image));
}
}
}
public HostLoadIndicatorViewModel(IRSessionProvider sessionProvider, ICoreShell shell) {
_sessionProvider = sessionProvider;
_shell = shell;
_disposableBag = DisposableBag.Create<HostLoadIndicatorViewModel>()
.Add(() => _sessionProvider.HostLoadChanged -= OnHostLoadChanged);
_sessionProvider.HostLoadChanged += OnHostLoadChanged;
}
public HostLoadIndicatorViewModel(IRSessionProvider sessionProvider, ICoreShell shell)
{
_sessionProvider = sessionProvider;
_shell = shell;
_disposableBag = DisposableBag.Create <HostLoadIndicatorViewModel>()
.Add(() => _sessionProvider.HostLoadChanged -= OnHostLoadChanged);
_sessionProvider.HostLoadChanged += OnHostLoadChanged;
}
public void ReleaseSubscriptions()
{
_currentProjectContext = null;
// We can't re-use the DisposableBag after disposing it, so null it out
// to ensure we create a new one the next time we go to add subscriptions.
_subscriptions?.Dispose();
_subscriptions = null;
}
public ConnectionStatusBarViewModel(IConnectionManager connectionManager, ICoreShell shell) {
_connectionManager = connectionManager;
_shell = shell;
_disposableBag = DisposableBag.Create<ConnectionStatusBarViewModel>()
.Add(() => connectionManager.ConnectionStateChanged -= ConnectionStateChanged);
connectionManager.ConnectionStateChanged += ConnectionStateChanged;
IsConnected = connectionManager.IsConnected;
SelectedConnection = connectionManager.ActiveConnection?.Name;
}
public Consumer(ISubscriber <MyEvent> subscriber)
{
var bag = DisposableBag.CreateBuilder();
_subscriber = subscriber;
_subscriber.Subscribe(Events.Add).AddTo(bag);
_disposable = bag.Build();
}
public Subscriber(ISubscriber <MyEvent> subscriber)
{
var bag = DisposableBag.CreateBuilder();
subscriber
.Subscribe(x => Debug.Log($"{x.Message}"))
.AddTo(bag);
_disposable = bag.Build();
}
private async Task ConnectToBrokerWorkerAsync(CancellationToken cancellationToken)
{
Trace.Assert(_brokerProcess == null);
var fs = _services.FileSystem();
var locator = new BrokerExecutableLocator(fs);
var rhostBrokerExe = locator.GetBrokerExecutablePath();
// _services.UI().LogMessage($"R Host broker: {rhostBrokerExe}");
if (!fs.FileExists(rhostBrokerExe))
{
throw new RHostBrokerBinaryMissingException();
}
IProcess process = null;
try {
var pipeName = Guid.NewGuid().ToString();
var cts = new CancellationTokenSource(Debugger.IsAttached ? 500000 : 100000);
using (var processConnectCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken, cts.Token))
using (var serverUriPipe = new NamedPipeServerStream(pipeName, PipeDirection.In, 1, PipeTransmissionMode.Byte, PipeOptions.Asynchronous)) {
var psi = GetProcessStartInfo(rhostBrokerExe, pipeName);
// _services.UI().LogMessage($"Starting R Host broker: {rhostBrokerExe}");
process = StartBroker(psi);
process.Exited += delegate {
cts.Cancel();
_brokerProcess = null;
_connectLock.EnqueueReset();
};
var uri = await GetBrokerUri(serverUriPipe, processConnectCts.Token, cts.Token);
CreateHttpClient(uri);
}
if (DisposableBag.TryAdd(DisposeBrokerProcess))
{
_brokerProcess = process;
}
} catch (Exception ex) {
_services.UI().LogMessage($"Unable to start R Host broker process. Exception {ex.Message}");
throw;
} finally {
if (_brokerProcess == null)
{
try {
process?.Kill();
} catch (Exception) {
} finally {
process?.Dispose();
}
}
}
}
public ConnectionStatusBarViewModel(IConnectionManager connectionManager, ICoreShell shell)
{
_connectionManager = connectionManager;
_shell = shell;
_disposableBag = DisposableBag.Create <ConnectionStatusBarViewModel>()
.Add(() => connectionManager.ConnectionStateChanged -= ConnectionStateChanged);
connectionManager.ConnectionStateChanged += ConnectionStateChanged;
IsConnected = connectionManager.IsConnected;
SelectedConnection = connectionManager.ActiveConnection?.Name;
}
public RInteractiveWorkflow(IServiceContainer services)
{
Services = services.Extend()
.AddService <IRInteractiveWorkflow>(this)
.AddService <IRSessionProvider, RSessionProvider>();
RSession = RSessions.GetOrCreate(SessionNames.InteractiveWindow);
_disposableBag = DisposableBag.Create <RInteractiveWorkflow>()
.Add(RSessions);
}
public RPlotManager(IRSettings settings, IRInteractiveWorkflow interactiveWorkflow, IFileSystem fileSystem)
{
_interactiveWorkflow = interactiveWorkflow;
_fileSystem = fileSystem;
_disposableBag = DisposableBag.Create <RPlotManager>()
.Add(() => interactiveWorkflow.RSession.Connected -= RSession_Connected)
.Add(() => interactiveWorkflow.RSession.Mutated -= RSession_Mutated);
interactiveWorkflow.RSession.Connected += RSession_Connected;
interactiveWorkflow.RSession.Mutated += RSession_Mutated;
}
#pragma warning restore CS0067
public PythonLanguageClientContextGlobal(IInterpreterOptionsService optionsService)
{
_optionsService = optionsService ?? throw new ArgumentNullException(nameof(optionsService));
_disposables = new DisposableBag(GetType().Name);
_factory = _optionsService.DefaultInterpreter;
_optionsService.DefaultInterpreterChanged += OnInterpreterChanged;
_disposables.Add(() => {
_optionsService.DefaultInterpreterChanged -= OnInterpreterChanged;
});
}
protected ConnectionStatusBaseViewModel(IConnectionManager connectionManager, ICoreShell shell)
{
ConnectionManager = connectionManager;
Shell = shell;
_disposableBag = DisposableBag.Create <ConnectionStatusBarViewModel>()
.Add(() => connectionManager.ConnectionStateChanged -= ConnectionStateChanged);
connectionManager.ConnectionStateChanged += ConnectionStateChanged;
IsConnected = connectionManager.IsConnected;
IsRunning = connectionManager.IsRunning;
}
protected ConnectionStatusBaseViewModel(IConnectionManager connectionManager, IServiceContainer services)
{
ConnectionManager = connectionManager;
Services = services;
_disposableBag = DisposableBag.Create <ConnectionStatusBarViewModel>()
.Add(() => connectionManager.ConnectionStateChanged -= ConnectionStateChanged);
connectionManager.ConnectionStateChanged += ConnectionStateChanged;
IsConnected = connectionManager.IsConnected;
IsRunning = connectionManager.IsRunning;
}
public RPlotManager(IRSettings settings, IRInteractiveWorkflow interactiveWorkflow, IFileSystem fileSystem) {
_interactiveWorkflow = interactiveWorkflow;
_fileSystem = fileSystem;
_shell = _interactiveWorkflow.Shell;
_disposableBag = DisposableBag.Create<RPlotManager>()
.Add(() => interactiveWorkflow.RSession.Connected -= RSession_Connected)
.Add(() => interactiveWorkflow.RSession.Mutated -= RSession_Mutated);
interactiveWorkflow.RSession.Connected += RSession_Connected;
interactiveWorkflow.RSession.Mutated += RSession_Mutated;
}
public ConnectionManagerViewModel(IConnectionManager connectionManager, ICoreShell shell)
{
_connectionManager = connectionManager;
_shell = shell;
_disposableBag = DisposableBag.Create <ConnectionManagerViewModel>()
.Add(() => connectionManager.ConnectionStateChanged -= ConnectionStateChanged);
_items = new BatchObservableCollection <IConnectionViewModel>();
Items = new ReadOnlyObservableCollection <IConnectionViewModel>(_items);
connectionManager.ConnectionStateChanged += ConnectionStateChanged;
IsConnected = connectionManager.IsConnected;
UpdateConnections();
}
public void Subscribe()
{
var bag = DisposableBag.CreateBuilder();
// イベントが来たら反応する
_subscriber
.Subscribe(ev =>
{
Debug.Log($"イベント受信完了: {ev.Message}");
}).AddTo(bag);
_disposable = bag.Build();
}
private RHostSession(IRSession session)
{
_session = session;
_session.Connected += OnSessionConnected;
_session.Disconnected += OnSessionDisconnected;
_session.Output += OnSessionOutput;
_disposableBag = DisposableBag.Create <RHostSession>()
.Add(() => _session.Output -= OnSessionOutput)
.Add(() => _session.Connected -= OnSessionConnected)
.Add(() => _session.Disconnected -= OnSessionDisconnected);
}
public RPlotManager(IRInteractiveWorkflowVisual interactiveWorkflow)
{
_interactiveWorkflow = interactiveWorkflow;
_fileSystem = interactiveWorkflow.Services.FileSystem();
_mainThread = _interactiveWorkflow.Services.MainThread();
_disposableBag = DisposableBag.Create <RPlotManager>()
.Add(() => interactiveWorkflow.RSession.Connected -= RSession_Connected)
.Add(() => interactiveWorkflow.RSession.Mutated -= RSession_Mutated);
interactiveWorkflow.RSession.Connected += RSession_Connected;
interactiveWorkflow.RSession.Mutated += RSession_Mutated;
}
public PythonLanguageClientContextWorkspace(IPythonWorkspaceContext pythonWorkspace)
{
_pythonWorkspace = pythonWorkspace ?? throw new ArgumentNullException(nameof(pythonWorkspace));
_disposables = new DisposableBag(GetType().Name);
_pythonWorkspace.ActiveInterpreterChanged += OnInterpreterChanged;
_pythonWorkspace.SearchPathsSettingChanged += OnSearchPathsChanged;
_disposables.Add(() => {
_pythonWorkspace.ActiveInterpreterChanged -= OnInterpreterChanged;
_pythonWorkspace.SearchPathsSettingChanged -= OnSearchPathsChanged;
});
_pythonWorkspace.AddActionOnClose(this, (obj) => Closed?.Invoke(this, EventArgs.Empty));
}
protected ConnectionStatusBaseViewModel(IServiceContainer services)
{
Services = services;
ConnectionManager = services.GetService <IConnectionManager>();
_disposableBag = DisposableBag.Create <ConnectionStatusBarViewModel>()
.Add(() => ConnectionManager.ConnectionStateChanged -= ConnectionStateChanged)
.Add(() => ConnectionManager.RecentConnectionsChanged -= RecentConnectionsChanged);
ConnectionManager.ConnectionStateChanged += ConnectionStateChanged;
ConnectionManager.RecentConnectionsChanged += RecentConnectionsChanged;
IsConnected = ConnectionManager.IsConnected;
IsRunning = ConnectionManager.IsRunning;
}
public PythonLanguageClientContextProject(PythonProjectNode project)
{
_project = project ?? throw new ArgumentNullException(nameof(project));
_disposables = new DisposableBag(GetType().Name);
_project.LanguageServerInterpreterChanged += OnInterpreterChanged;
_project.LanguageServerSearchPathsChanged += OnSearchPathsChanged;
_disposables.Add(() => {
_project.LanguageServerInterpreterChanged -= OnInterpreterChanged;
_project.LanguageServerSearchPathsChanged -= OnSearchPathsChanged;
});
_project.AddActionOnClose(this, (obj) => Closed?.Invoke(this, EventArgs.Empty));
}
public void Start()
{
var d = DisposableBag.CreateBuilder();
subscriber.Subscribe(x => Debug.Log("P1:" + x)).AddTo(d);
subscriber.Subscribe(x => Debug.Log("P2:" + x)).AddTo(d);
publisher.Publish(10);
publisher.Publish(20);
publisher.Publish(30);
var disposable = d.Build();
disposable.Dispose();
}
protected override void Initialize()
{
base.Initialize();
IDisposable projectRuleSourceLink = _project.Services.ProjectSubscription.ProjectRuleSource.SourceBlock.LinkToAsyncAction(ProcessProjectChanged, ruleNames: PotentialEditorConfigFiles.SchemaName);
IDisposable join = JoinUpstreamDataSources(_project.Services.ProjectSubscription.ProjectRuleSource);
_disposables = new DisposableBag();
_disposables.AddDisposable(projectRuleSourceLink);
_disposables.AddDisposable(join);
_broadcastBlock = DataflowBlockSlim.CreateBroadcastBlock <IProjectVersionedValue <FileWatchData> >(nameFormat: nameof(PotentialEditorConfigDataSource) + "Broadcast {1}");
_publicBlock = _broadcastBlock.SafePublicize();
}
public ConnectionManagerViewModel(IConnectionManager connectionManager, ICoreShell shell) {
_connectionManager = connectionManager;
_shell = shell;
_disposableBag = DisposableBag.Create<ConnectionManagerViewModel>()
.Add(() => connectionManager.ConnectionStateChanged -= ConnectionStateChanged);
_remoteConnections = new BatchObservableCollection<IConnectionViewModel>();
RemoteConnections = new ReadOnlyObservableCollection<IConnectionViewModel>(_remoteConnections);
_localConnections = new BatchObservableCollection<IConnectionViewModel>();
LocalConnections = new ReadOnlyObservableCollection<IConnectionViewModel>(_localConnections);
connectionManager.ConnectionStateChanged += ConnectionStateChanged;
IsConnected = connectionManager.IsConnected;
UpdateConnections();
}
public override IDisposable AcquireDistributedLock(string resource, TimeSpan timeout)
{
var connection = _storage.CreateAndOpenConnection();
try
{
var handle = new MySqlDistributedLock(connection, resource, timeout, _storageOptions);
handle.Acquire();
return(DisposableBag.Create(handle, connection));
}
catch
{
connection.Dispose();
throw;
}
}
private void OnActiveConfigurationsChanged(IProjectVersionedValue <IConfigurationGroup <ConfiguredProject> > e)
{
if (IsDisposing || IsDisposed)
{
return;
}
// Clean up past subscriptions
_designTimeBuildSubscriptionLink?.Dispose();
if (e.Value.Count > 0)
{
var sourceLinkOptions = new StandardRuleDataflowLinkOptions
{
RuleNames = s_designTimeBuildWatchedRules,
PropagateCompletion = true
};
var disposableBag = new DisposableBag(CancellationToken.None);
// We are taking source blocks from multiple configured projects and creating a SyncLink to combine the sources.
// The SyncLink will only publish data when the versions of the sources match. There is a problem with that.
// The sources have some version components that will make this impossible to match across TFMs. We introduce a
// intermediate block here that will remove those version components so that the synclink can actually sync versions.
IEnumerable <ProjectDataSources.SourceBlockAndLink <IProjectValueVersions> > sourceBlocks = e.Value.Select(
cp =>
{
IReceivableSourceBlock <IProjectVersionedValue <IProjectSubscriptionUpdate> > sourceBlock = cp.Services.ProjectSubscription.JointRuleSource.SourceBlock;
IPropagatorBlock <IProjectVersionedValue <IProjectSubscriptionUpdate>, IProjectVersionedValue <IProjectSubscriptionUpdate> > versionDropper = CreateVersionDropperBlock();
disposableBag.AddDisposable(sourceBlock.LinkTo(versionDropper, sourceLinkOptions));
return(versionDropper.SyncLinkOptions <IProjectValueVersions>(sourceLinkOptions));
});
Action <Tuple <ImmutableList <IProjectValueVersions>, TIdentityDictionary> > action = ProjectPropertyChanged;
var target = new ActionBlock <Tuple <ImmutableList <IProjectValueVersions>, TIdentityDictionary> >(action);
var targetLinkOptions = new DataflowLinkOptions {
PropagateCompletion = true
};
ImmutableList <ProjectDataSources.SourceBlockAndLink <IProjectValueVersions> > sourceBlocksAndCapabilitiesOptions = sourceBlocks.ToImmutableList()
.Insert(0, _projectVsServices.Project.Capabilities.SourceBlock.SyncLinkOptions <IProjectValueVersions>());
disposableBag.AddDisposable(ProjectDataSources.SyncLinkTo(sourceBlocksAndCapabilitiesOptions, target, targetLinkOptions));
_designTimeBuildSubscriptionLink = disposableBag;
}
}
public RInteractiveWorkflow(IRSessionProvider sessionProvider
, IConnectionManagerProvider connectionsProvider
, IRHistoryProvider historyProvider
, IRPackageManagerProvider packagesProvider
, IRPlotManagerProvider plotsProvider
, IActiveWpfTextViewTracker activeTextViewTracker
, IDebuggerModeTracker debuggerModeTracker
, ICoreShell coreShell
, IRSettings settings
, IWorkspaceServices wss
, Action onDispose)
{
_activeTextViewTracker = activeTextViewTracker;
_debuggerModeTracker = debuggerModeTracker;
_settings = settings;
_wss = wss;
_onDispose = onDispose;
Shell = coreShell;
RSessions = sessionProvider;
RSession = sessionProvider.GetOrCreate(GuidList.InteractiveWindowRSessionGuid);
Connections = connectionsProvider.CreateConnectionManager(this);
History = historyProvider.CreateRHistory(this);
Packages = packagesProvider.CreateRPackageManager(settings, this);
Plots = plotsProvider.CreatePlotManager(settings, this, new FileSystem());
_operations = new RInteractiveWorkflowOperations(this, _debuggerModeTracker, Shell);
_activeTextViewTracker.LastActiveTextViewChanged += LastActiveTextViewChanged;
RSession.Disconnected += RSessionDisconnected;
_debuggerModeTracker.EnterBreakMode += DebuggerEnteredBreakMode;
_debuggerModeTracker.LeaveBreakMode += DebuggerLeftBreakMode;
_settings.PropertyChanged += OnSettingsChanged;
_disposableBag = DisposableBag.Create <RInteractiveWorkflow>()
.Add(() => _settings.PropertyChanged -= OnSettingsChanged)
.Add(() => _debuggerModeTracker.EnterBreakMode -= DebuggerEnteredBreakMode)
.Add(() => _debuggerModeTracker.LeaveBreakMode -= DebuggerLeftBreakMode)
.Add(() => _activeTextViewTracker.LastActiveTextViewChanged -= LastActiveTextViewChanged)
.Add(() => RSession.Disconnected -= RSessionDisconnected)
.Add(Operations)
.Add(Connections).
Add(_onDispose);
}
public BraceHighlightTagger(IServiceProvider site, ITextView textView, ITextBuffer buffer)
{
_site = site ?? throw new ArgumentNullException(nameof(site));
_textView = textView ?? throw new ArgumentNullException(nameof(textView));
_buffer = buffer ?? throw new ArgumentNullException(nameof(buffer));
_currentChar = null;
_textView.Caret.PositionChanged += CaretPositionChanged;
_textView.LayoutChanged += ViewLayoutChanged;
_disposableBag = new DisposableBag(GetType().Name);
_disposableBag.Add(() => {
_textView.Caret.PositionChanged -= CaretPositionChanged;
_textView.LayoutChanged -= ViewLayoutChanged;
});
}
private async Task EnsureBrokerStartedAsync(CancellationToken cancellationToken)
{
DisposableBag.ThrowIfDisposed();
await TaskUtilities.SwitchToBackgroundThread();
var lockToken = await _connectLock.WaitAsync(cancellationToken);
try {
if (!lockToken.IsSet)
{
await ConnectToBrokerWorker(cancellationToken);
}
lockToken.Set();
} finally {
lockToken.Reset();
}
}
protected override async Task ConnectToBrokerAsync()
{
DisposableBag.ThrowIfDisposed();
await TaskUtilities.SwitchToBackgroundThread();
try {
if (!await _connectLock.WaitAsync())
{
if (_brokerProcess == null)
{
await ConnectToBrokerWorker();
}
}
} finally {
_connectLock.Release();
}
}
public void Initialize()
{
var bag = DisposableBag.CreateBuilder();
_gameStateSubscriber.Subscribe(async(stateEnum, token) =>
{
if (stateEnum != GameStateEnum.MainMenu)
{
return;
}
_baseObject.SetActive(true);
await _startButton.OnClickAsync(token);
_baseObject.SetActive(false);
}).AddTo(bag);
_subscription = bag.Build();
}
private async Task ResetSubscriptionsAsync()
{
// active configuration should be updated before resetting subscriptions
await RefreshActiveConfigurationAsync().ConfigureAwait(false);
_designTimeBuildSubscriptionLink?.Dispose();
var currentProjects = await _activeConfiguredProjectsProvider.GetActiveConfiguredProjectsAsync()
.ConfigureAwait(false);
if (currentProjects != null)
{
var sourceLinkOptions = new StandardRuleDataflowLinkOptions
{
RuleNames = s_designTimeBuildWatchedRules,
PropagateCompletion = true
};
var disposableBag = new DisposableBag(CancellationToken.None);
// We are taking source blocks from multiple configured projects and creating a SyncLink to combine the sources.
// The SyncLink will only publish data when the versions of the sources match. There is a problem with that.
// The sources have some version components that will make this impossible to match across TFMs. We introduce a
// intermediate block here that will remove those version components so that the synclink can actually sync versions.
var sourceBlocks = currentProjects.Objects.Select(
cp =>
{
var sourceBlock = cp.Services.ProjectSubscription.JointRuleSource.SourceBlock;
var versionDropper = CreateVersionDropperBlock();
disposableBag.AddDisposable(sourceBlock.LinkTo(versionDropper, sourceLinkOptions));
return(versionDropper.SyncLinkOptions <IProjectValueVersions>(sourceLinkOptions));
});
var target = new ActionBlock <Tuple <ImmutableList <IProjectValueVersions>, TIdentityDictionary> >(ProjectPropertyChangedAsync);
var targetLinkOptions = new DataflowLinkOptions {
PropagateCompletion = true
};
disposableBag.AddDisposable(ProjectDataSources.SyncLinkTo(sourceBlocks.ToImmutableList(), target, targetLinkOptions));
_designTimeBuildSubscriptionLink = disposableBag;
}
}
public RPlotHistoryVisualComponent(IRPlotManager plotManager, IVisualComponentContainer <IRPlotHistoryVisualComponent> container, IServiceContainer services)
{
Check.ArgumentNull(nameof(plotManager), plotManager);
Check.ArgumentNull(nameof(container), container);
Check.ArgumentNull(nameof(services), services);
var control = new RPlotHistoryControl();
_viewModel = new RPlotHistoryViewModel(control, plotManager, services.MainThread());
control.DataContext = _viewModel;
_disposableBag = DisposableBag.Create <RPlotDeviceVisualComponent>()
.Add(() => control.ContextMenuRequested -= Control_ContextMenuRequested);
control.ContextMenuRequested += Control_ContextMenuRequested;
Control = control;
Container = container;
}
protected override IDisposable LinkExternalInput(ITargetBlock <RestoreInfo> targetBlock)
{
// At a high-level, we want to combine all implicitly active configurations (ie the active config of each TFM) restore data
// (via ProjectRestoreUpdate) and combine it into a single IVsProjectRestoreInfo2 instance and publish that. When a change is
// made to a configuration, such as adding a PackageReference, we should react to it and push a new version of our output. If the
// active configuration changes, we should react to it, and publish data from the new set of implicitly active configurations.
var disposables = new DisposableBag();
var restoreConfiguredInputSource = new UnwrapCollectionChainedProjectValueDataSource <IReadOnlyCollection <ConfiguredProject>, PackageRestoreConfiguredInput>(
_project,
projects => projects.Select(project => project.Services.ExportProvider.GetExportedValueOrDefault <IPackageRestoreConfiguredInputDataSource>())
.WhereNotNull() // Filter out those without PackageReference
.Select(DropConfiguredProjectVersions),
includeSourceVersions: true);
disposables.Add(restoreConfiguredInputSource);
IProjectValueDataSource <IConfigurationGroup <ConfiguredProject> > activeConfiguredProjectsSource = _activeConfigurationGroupService.ActiveConfiguredProjectGroupSource;
disposables.Add(activeConfiguredProjectsSource.SourceBlock.LinkTo(restoreConfiguredInputSource, DataflowOption.PropagateCompletion));
// Dataflow from two configurations can depend on a same unconfigured level data source, and processes it at a different speed.
// Introduce a forward-only block to prevent regressions in versions.
var forwardOnlyBlock = ProjectDataSources.CreateDataSourceVersionForwardOnlyFilteringBlock <IReadOnlyCollection <PackageRestoreConfiguredInput> >();
disposables.Add(restoreConfiguredInputSource.SourceBlock.LinkTo(forwardOnlyBlock, DataflowOption.PropagateCompletion));
// Transform all restore data -> combined restore data
DisposableValue <ISourceBlock <RestoreInfo> > mergeBlock = forwardOnlyBlock.TransformWithNoDelta(update => update.Derive(MergeRestoreInputs));
disposables.Add(mergeBlock);
// Set the link up so that we publish changes to target block
mergeBlock.Value.LinkTo(targetBlock, DataflowOption.PropagateCompletion);
// Join the source blocks, so if they need to switch to UI thread to complete
// and someone is blocked on us on the same thread, the call proceeds
JoinUpstreamDataSources(restoreConfiguredInputSource, activeConfiguredProjectsSource);
_packageReferenceTelemetryService.PostPackageRestoreEvent(PackageRestoreOperationNames.PackageRestoreUnconfiguredInputDataSourceLinkedToExternalInput);
return(disposables);
}
public RPlotDeviceVisualComponent(IRPlotManager plotManager, ICommandTarget controller, int instanceId, IVisualComponentContainer<IRPlotDeviceVisualComponent> container, ICoreShell coreShell) {
if (plotManager == null) {
throw new ArgumentNullException(nameof(plotManager));
}
if (container == null) {
throw new ArgumentNullException(nameof(container));
}
if (coreShell == null) {
throw new ArgumentNullException(nameof(coreShell));
}
_plotManager = plotManager;
_viewModel = new RPlotDeviceViewModel(plotManager, coreShell, instanceId);
_shell = coreShell;
var control = new RPlotDeviceControl {
DataContext = _viewModel,
};
_disposableBag = DisposableBag.Create<RPlotDeviceVisualComponent>()
.Add(() => control.ContextMenuRequested -= Control_ContextMenuRequested)
.Add(() => _viewModel.DeviceNameChanged -= ViewModel_DeviceNameChanged)
.Add(() => _viewModel.LocatorModeChanged -= ViewModel_LocatorModeChanged)
.Add(() => _viewModel.PlotChanged += ViewModel_PlotChanged)
.Add(() => _plotManager.ActiveDeviceChanged += PlotManager_ActiveDeviceChanged);
control.ContextMenuRequested += Control_ContextMenuRequested;
_viewModel.DeviceNameChanged += ViewModel_DeviceNameChanged;
_viewModel.LocatorModeChanged += ViewModel_LocatorModeChanged;
_viewModel.PlotChanged += ViewModel_PlotChanged;
_plotManager.ActiveDeviceChanged += PlotManager_ActiveDeviceChanged;
Control = control;
Controller = controller;
Container = container;
}
public RInteractiveWorkflow(IConnectionManagerProvider connectionsProvider
, IRHistoryProvider historyProvider
, IRPackageManagerProvider packagesProvider
, IRPlotManagerProvider plotsProvider
, IActiveWpfTextViewTracker activeTextViewTracker
, IDebuggerModeTracker debuggerModeTracker
, ICoreShell coreShell
, IRSettings settings) {
_activeTextViewTracker = activeTextViewTracker;
_debuggerModeTracker = debuggerModeTracker;
_settings = settings;
Shell = coreShell;
RSessions = new RSessionProvider(coreShell.Services, new InteractiveWindowConsole(this));
RSession = RSessions.GetOrCreate(SessionGuids.InteractiveWindowRSessionGuid);
RSession.RestartOnBrokerSwitch = true;
Connections = connectionsProvider.CreateConnectionManager(this);
History = historyProvider.CreateRHistory(this);
Packages = packagesProvider.CreateRPackageManager(settings, this);
Plots = plotsProvider.CreatePlotManager(settings, this, new FileSystem());
_operations = new RInteractiveWorkflowOperations(this, _debuggerModeTracker, Shell);
_activeTextViewTracker.LastActiveTextViewChanged += LastActiveTextViewChanged;
RSession.Disconnected += RSessionDisconnected;
_debuggerModeTracker.EnterBreakMode += DebuggerEnteredBreakMode;
_debuggerModeTracker.LeaveBreakMode += DebuggerLeftBreakMode;
_settings.PropertyChanged += OnSettingsChanged;
_disposableBag = DisposableBag.Create<RInteractiveWorkflow>()
.Add(() => _settings.PropertyChanged -= OnSettingsChanged)
.Add(() => _debuggerModeTracker.EnterBreakMode -= DebuggerEnteredBreakMode)
.Add(() => _debuggerModeTracker.LeaveBreakMode -= DebuggerLeftBreakMode)
.Add(() => _activeTextViewTracker.LastActiveTextViewChanged -= LastActiveTextViewChanged)
.Add(() => RSession.Disconnected -= RSessionDisconnected)
.Add(RSessions)
.Add(Operations)
.Add(Connections);
}
