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