public ExampleForm(ExportProvider exportProvider) { _shaderFragments = exportProvider.GetExport <ShaderFragmentArchive.Archive>().Value; _nodeCreator = exportProvider.GetExport <NodeEditorCore.IShaderFragmentNodeCreator>().Value; _modelConversion = exportProvider.GetExport <NodeEditorCore.IModelConversion>().Value; InitializeComponent(); _hyperGraphModel = new HyperGraph.GraphModel(); _hyperGraphModel.CompatibilityStrategy = _nodeCreator.CreateCompatibilityStrategy(); _graphAdapter = new HyperGraph.GraphControl(); _graphAdapter.Attach(graphControl); _graphAdapter.HighlightCompatible = true; _graphAdapter.LargeGridStep = 160F; _graphAdapter.LargeStepGridColor = System.Drawing.Color.FromArgb(((int)(((byte)(90)))), ((int)(((byte)(90)))), ((int)(((byte)(90))))); _graphAdapter.ShowLabels = false; _graphAdapter.SmallGridStep = 20F; _graphAdapter.SmallStepGridColor = System.Drawing.Color.FromArgb(((int)(((byte)(80)))), ((int)(((byte)(80)))), ((int)(((byte)(80))))); _graphAdapter.Model = _hyperGraphModel; _graphAdapter.Selection = new GraphSelection(); _graphAdapter.Selection.SelectionChanged += OnFocusChanged; graphControl.MouseEnter += OnGraphMouseEnter; graphControl.Paint += graphControl_Paint; _tabGroupTextureNode = new RibbonTabGroup(_ribbon, (uint)RibbonMarkupCommands.cmdTabGroupTextureNode); _showLabels = new RibbonLib.Controls.RibbonCheckBox(_ribbon, (uint)RibbonMarkupCommands.cmdShowLabels); _showLabels.ExecuteEvent += new EventHandler <ExecuteEventArgs>(OnShowLabelsChanged); _generateTestScript = new RibbonLib.Controls.RibbonButton(_ribbon, (uint)RibbonMarkupCommands.cmdButtonTestScript); _generateTestScript.ExecuteEvent += new EventHandler <ExecuteEventArgs>(OnGenerateTestScript); _saveAsButton = new RibbonLib.Controls.RibbonButton(_ribbon, (uint)RibbonMarkupCommands.cmdSaveAs); _saveAsButton.ExecuteEvent += new EventHandler <ExecuteEventArgs>(OnSaveAs); _loadButton = new RibbonLib.Controls.RibbonButton(_ribbon, (uint)RibbonMarkupCommands.cmdLoad); _loadButton.ExecuteEvent += new EventHandler <ExecuteEventArgs>(OnLoad); var fragmentTreeModel = exportProvider.GetExport <NodeEditorCore.ShaderFragmentArchiveModel>().Value; _fragmentTree.Model = new Aga.Controls.Tree.SortedTreeModel(fragmentTreeModel); _fragmentTree.ItemDrag += new ItemDragEventHandler(OnFragmentTreeItemDrag); _fragmentTree.NodeMouseDoubleClick += new EventHandler <Aga.Controls.Tree.TreeNodeAdvMouseEventArgs>(OnFragmentTreeItemDoubleClick); // _materialParametersGrid.SelectedObject = new DictionaryPropertyGridAdapter(_document.PreviewMaterialState); try { LoadFile("defaultload.sh"); } catch (System.Exception) {} }
public void Initialize() { var encryptionProvider = ExportProvider.GetExport <IEncryptionProvider>(); var keys = encryptionProvider.GenerateSecretKeys(); encryptionProvider.SetSecretKeys(keys); }
public async Task UpdateAccountAsyncTest() { using (DataManager dataManager = await CreateDataManagerAsync().ConfigureAwait(false)) { await dataManager.LoadOrCreateLocalUserDataBundleAsync(CancellationToken.None).ConfigureAwait(false); var categoryAllId = new Guid(Constants.CategoryAllId); var account1 = new Account(await dataManager.GenerateUniqueIdAsync(CancellationToken.None).ConfigureAwait(false)) { Title = "Foo", CategoryID = categoryAllId }; var account2 = new Account(await dataManager.GenerateUniqueIdAsync(CancellationToken.None).ConfigureAwait(false)) { Title = "Bar", CategoryID = categoryAllId }; await dataManager.AddNewAccountAsync(account1, CancellationToken.None).ConfigureAwait(false); account1 = ExportProvider.GetExport <ISerializationProvider>().CloneObject(account1); // clone the account, so we're sure they're not same object reference. await dataManager.UpdateAccountAsync(account1, account2, CancellationToken.None).ConfigureAwait(false); var allAccounts = await dataManager.SearchAsync(categoryAllId, string.Empty, CancellationToken.None).ConfigureAwait(false); Assert.AreEqual(1, allAccounts.Count); Assert.AreEqual("Bar", allAccounts[0].Title); } }
public async Task SignInFails() { var service = CreateRemoteSynchronizationService(); var settingsProvider = ExportProvider.GetExport <ISettingsProvider>(); _mockRemoteStorageProvider.SignInAsyncResult = false; var tcs = new TaskCompletionSource <bool>(); SynchronizationResultEventArgs resultEventArgs = null; service.SynchronizationCompleted += (s, e) => { resultEventArgs = e; tcs.SetResult(true); }; service.QueueSynchronization(); await tcs.Task.ConfigureAwait(false); Assert.IsNotNull(resultEventArgs); Assert.IsFalse(resultEventArgs.Succeeded); Assert.IsFalse(resultEventArgs.RequiresReloadLocalData); Assert.IsFalse(settingsProvider.GetSetting(SettingsDefinitions.SyncDataWithCloud)); }
/// <summary> /// Initialization of the package; this method is called right after the package is sited, so this is the place /// where you can put all the initialization code that rely on services provided by VisualStudio. /// </summary> protected override void Initialize() { base.Initialize(); // An remember the package. Instance = this; // Register the command handlers. CloudExplorerCommand.Initialize(this); ManageAccountsCommand.Initialize(this); PublishProjectMainMenuCommand.Initialize(this); PublishProjectContextMenuCommand.Initialize(this); LogsViewerToolWindowCommand.Initialize(this); GenerateConfigurationContextMenuCommand.Initialize(this); ErrorReportingToolWindowCommand.Initialize(this); // Activity log utils, to aid in debugging. ActivityLogUtils.Initialize(this); ActivityLogUtils.LogInfo("Starting Google Cloud Tools."); _dteInstance = (DTE)GetService(typeof(DTE)); VsVersion = _dteInstance.Version; VsEdition = _dteInstance.Edition; // Update the installation status of the package. CheckInstallationStatus(); // Ensure the commands UI state is updated when the GCP project changes. CredentialsStore.Default.Reset += (o, e) => ShellUtils.InvalidateCommandsState(); CredentialsStore.Default.CurrentProjectIdChanged += (o, e) => ShellUtils.InvalidateCommandsState(); // With this setting we allow more concurrent connections from each HttpClient instance created // in the process. This will allow all GCP API services to have more concurrent connections with // GCP servers. The first benefit of this is that we can upload more concurrent files to GCS. ServicePointManager.DefaultConnectionLimit = MaximumConcurrentConnections; ExportProvider mefExportProvider = GetService <SComponentModel, IComponentModel>().DefaultExportProvider; _shellUtilsLazy = mefExportProvider.GetExport <IShellUtils>(); _gcpOutputWindowLazy = mefExportProvider.GetExport <IGcpOutputWindow>(); _processService = mefExportProvider.GetExport <IProcessService>(); _statusbarService = mefExportProvider.GetExport <IStatusbarService>(); _userPromptService = mefExportProvider.GetExport <IUserPromptService>(); }
public void CloneObjectTest() { var data = new UserDataBundle(); data.Categories.Add(new Category(Guid.NewGuid(), "Category")); var dataCopy = ExportProvider.GetExport <ISerializationProvider>().CloneObject(data); Assert.AreEqual(data.GetHashCode(), data.GetHashCode()); Assert.AreNotEqual(data.GetHashCode(), dataCopy.GetHashCode()); }
public void LoggerSizeLimit() { ILogger logger = ExportProvider.GetExport <ILogger>(); for (int i = 0; i < 2000; i++) { logger.LogEvent("foo", i.ToString(CultureInfo.InvariantCulture)); } var logs = logger.GetAllLogs().ToString(); Assert.IsTrue(logs.StartsWith("foo ; 1000", System.StringComparison.Ordinal)); Assert.IsTrue(logs.EndsWith("foo ; 1999\r\n", System.StringComparison.Ordinal)); }
public void SettingsTest() { ISettingsProvider settingsProvider = ExportProvider.GetExport <ISettingsProvider>(); var setting = new SettingDefinition <bool>("dummySetting", isRoaming: false, defaultValue: true); // Remove previous setting if exists. settingsProvider.ResetSetting(setting); Assert.IsTrue(settingsProvider.GetSetting(setting)); settingsProvider.SetSetting(setting, false); Assert.IsFalse(settingsProvider.GetSetting(setting)); }
public async Task TwoFactorAuthProviderTest() { ITwoFactorAuthProvider provider = ExportProvider.GetExport <ITwoFactorAuthProvider>(); string pin1 = provider.GeneratePin(); Assert.IsTrue(provider.ValidatePin(pin1)); await Task.Delay(60000).ConfigureAwait(false); string pin2 = provider.GeneratePin(); Assert.AreNotEqual(pin1, pin2); Assert.IsTrue(provider.ValidatePin(pin2)); Assert.IsFalse(provider.ValidatePin(pin1, allowedInterval: 0)); }
private IRemoteSynchronizationService CreateRemoteSynchronizationService() { var settingsProvider = ExportProvider.GetExport <ISettingsProvider>(); var logger = ExportProvider.GetExport <ILogger>(); settingsProvider.SetSetting(SettingsDefinitions.SyncDataWithCloud, true); settingsProvider.SetSetting(SettingsDefinitions.RemoteStorageProviderName, nameof(MockIRemoteStorageProvider)); return(new RemoteSynchronizationService( settingsProvider, logger, new List <Lazy <IRemoteStorageProvider, RemoteStorageProviderMetadata> > { new Lazy <IRemoteStorageProvider, RemoteStorageProviderMetadata>( () => _mockRemoteStorageProvider, new RemoteStorageProviderMetadata { ProviderName = nameof(MockIRemoteStorageProvider) }) })); }
private void StartStatusCollect() { var interval = this.ConfigSource.StatusCollectInterval; if (interval == 0) { interval = 60; } interval = interval * 1000; var state = new StatusCollectState { Interval = interval, Collector = ExportProvider.GetExport <IStatusCollector>().Value, Logger = LoggerFactory.GetLogger("NRackStatus"), PerformanceCounter = new ProcessPerformanceCounter(Process.GetCurrentProcess(), PerformanceCounterInfo.GetDefaultPerformanceCounterDefinitions(), this.ConfigSource.Isolation == IsolationMode.None), BootstrapStatus = new AppServerStatus(GetBootstrapMetadata(), new StatusInfoCollection("[Bootstrap]")) }; m_StatusCollectTimer = new Timer(OnStatusCollectTimerCallback, state, interval, interval); }
private async Task <DataManager> CreateDataManagerAsync(bool clearExistingLocalData = true) { var logger = ExportProvider.GetExport <ILogger>(); var encryptionProvider = ExportProvider.GetExport <IEncryptionProvider>(); var serializationProvider = ExportProvider.GetExport <ISerializationProvider>(); var upgradeService = ExportProvider.GetExport <IUpgradeService>(); #pragma warning disable CA2000 // Dispose objects before losing scope var dataManager = new DataManager( logger, encryptionProvider, serializationProvider, new MockIRemoteSynchronizationService(), upgradeService); #pragma warning restore CA2000 // Dispose objects before losing scope if (clearExistingLocalData) { await dataManager.ClearLocalDataAsync(CancellationToken.None).ConfigureAwait(false); } return(dataManager); }
public async Task SyncNotEnabled() { var service = CreateRemoteSynchronizationService(); var settingsProvider = ExportProvider.GetExport <ISettingsProvider>(); settingsProvider.SetSetting(SettingsDefinitions.SyncDataWithCloud, false); service.SynchronizationStarted += (s, e) => { Assert.Fail(); }; service.SynchronizationCompleted += (s, e) => { Assert.Fail(); }; service.QueueSynchronization(); await Task.Delay(1000).ConfigureAwait(false); Assert.IsFalse(service.IsSynchronizing); }
/// <summary> /// Initialization of the package; this method is called right after the package is sited, so this is the place /// where you can put all the initialization code that rely on services provided by VisualStudio. /// </summary> protected override async Task InitializeAsync(CancellationToken token, IProgress <ServiceProgressData> progress) { try { _componentModel = await GetServiceAsync <SComponentModel, IComponentModel>(); CredentialsStore = _componentModel.GetService <ICredentialsStore>(); ExportProvider mefExportProvider = _componentModel.DefaultExportProvider; _shellUtilsLazy = mefExportProvider.GetExport <IShellUtils>(); _gcpOutputWindowLazy = mefExportProvider.GetExport <IGcpOutputWindow>(); _processService = mefExportProvider.GetExport <IProcessService>(); _statusbarService = mefExportProvider.GetExport <IStatusbarService>(); _userPromptService = mefExportProvider.GetExport <IUserPromptService>(); _dataSourceFactory = mefExportProvider.GetExport <IDataSourceFactory>(); Dte = await GetServiceAsync <SDTE, DTE2>(); // Remember the package. Instance = this; // Activity log utils, to aid in debugging. IVsActivityLog activityLog = await GetServiceAsync <SVsActivityLog, IVsActivityLog>(); await activityLog.LogInfoAsync("Starting Google Cloud Tools."); // Register the command handlers. await Task.WhenAll( CloudExplorerCommand.InitializeAsync(this, token), ManageAccountsCommand.InitializeAsync(this, token), PublishProjectMainMenuCommand.InitializeAsync(this, token), PublishProjectContextMenuCommand.InitializeAsync(this, token), LogsViewerToolWindowCommand.InitializeAsync(this, token), GenerateConfigurationContextMenuCommand.InitializeAsync(this, token), ErrorReportingToolWindowCommand.InitializeAsync(this, token)); // Update the installation status of the package. await CheckInstallationStatusAsync(); // Ensure the commands UI state is updated when the GCP project changes. CredentialsStore.CurrentProjectIdChanged += (o, e) => ShellUtils.InvalidateCommandsState(); // With this setting we allow more concurrent connections from each HttpClient instance created // in the process. This will allow all GCP API services to have more concurrent connections with // GCP servers. The first benefit of this is that we can upload more concurrent files to GCS. ServicePointManager.DefaultConnectionLimit = MaximumConcurrentConnections; IVsRegisterUIFactories registerUIFactories = await GetServiceAsync <SVsUIFactory, IVsRegisterUIFactories>(); var controlFactory = _componentModel.GetService <GcpMenuBarControlFactory>(); await registerUIFactories.RegisterUIFactoryAsync(controlFactory, token); } catch (Exception e) { IVsActivityLog activityLog = await GetServiceAsync <SVsActivityLog, IVsActivityLog>(); await activityLog.LogErrorAsync(e.Message); await activityLog.LogErrorAsync(e.StackTrace); } }
public async Task RecurrentTaskServiceTest() { await ExportProvider.GetExport <IDataManager>().ClearLocalDataAsync(CancellationToken.None).ConfigureAwait(false); await ExportProvider.GetExport <IDataManager>().LoadOrCreateLocalUserDataBundleAsync(CancellationToken.None).ConfigureAwait(false); RecurrentTaskService service = null; await TaskHelper.RunOnUIThreadAsync(() => { service = new RecurrentTaskService( ExportProvider.GetExport <ILogger>(), ExportProvider.GetExport <IDataManager>(), new List <Lazy <IRecurrentTask, RecurrentTaskMetadata> > { new Lazy <IRecurrentTask, RecurrentTaskMetadata>( () => new MockRecurrentTask(), new RecurrentTaskMetadata { Name = "Foo", Recurrency = TaskRecurrency.OneMinute }), new Lazy <IRecurrentTask, RecurrentTaskMetadata>( () => new MockRecurrentTask(), new RecurrentTaskMetadata { Name = "Bar", Recurrency = TaskRecurrency.OneDay }), new Lazy <IRecurrentTask, RecurrentTaskMetadata>( () => new MockRecurrentTask(), new RecurrentTaskMetadata { Name = "Boo", Recurrency = TaskRecurrency.Manual }) }); }).ConfigureAwait(false); var fooRunCount = 0; var barRunCount = 0; var booRunCount = 0; service.TaskCompleted += (s, e) => { Assert.AreEqual("Hello there", e.Result); if (e.TaskName == "Foo") { fooRunCount++; } else if (e.TaskName == "Bar") { barRunCount++; } else if (e.TaskName == "Boo") { booRunCount++; } }; service.Start(); await Task.Delay(65000).ConfigureAwait(false); // 1min 5 sec. service.Pause(); Assert.AreEqual(2, fooRunCount); Assert.AreEqual(1, barRunCount); Assert.AreEqual(0, booRunCount); service.Start(); service.RunTaskExplicitly("Boo"); await Task.Delay(2000).ConfigureAwait(false); Assert.AreEqual(2, fooRunCount); Assert.AreEqual(1, barRunCount); Assert.AreEqual(1, booRunCount); service.Dispose(); }
public object GetExport(string contractName) { return(ExportProvider.GetExport <object>(contractName).Value); }