ckaczor/azuredatastudio
1
0
Fork 0
mirror of https://github.com/ckaczor/azuredatastudio.git synced 2026-02-16 02:48:30 -05:00
Code Issues Packages Projects Releases Wiki Activity

Merge from vscode 7eaf220cafb9d9e901370ffce02229171cbf3ea6

Browse Source
This commit is contained in:
ADS Merger
2020-09-03 02:34:56 +00:00
committed by Anthony Dresser
parent 39d9eed585
commit a63578e6f7
519 changed files with 14338 additions and 6670 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
src/vs/workbench/contrib/userDataSync/browser/userDataAutoSyncService.ts
View File

@@ -1,42 +0,0 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { IUserDataSyncService, IUserDataSyncLogService, IUserDataSyncResourceEnablementService, IUserDataSyncStoreService, IUserDataSyncStoreManagementService } from 'vs/platform/userDataSync/common/userDataSync';
import { Event } from 'vs/base/common/event';
import { UserDataAutoSyncService as BaseUserDataAutoSyncService } from 'vs/platform/userDataSync/common/userDataAutoSyncService';
import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
import { IHostService } from 'vs/workbench/services/host/browser/host';
import { IUserDataSyncAccountService } from 'vs/platform/userDataSync/common/userDataSyncAccount';
import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
import { UserDataSyncTrigger } from 'vs/workbench/contrib/userDataSync/browser/userDataSyncTrigger';
import { IStorageService } from 'vs/platform/storage/common/storage';
import { IEnvironmentService } from 'vs/platform/environment/common/environment';
import { IUserDataSyncMachinesService } from 'vs/platform/userDataSync/common/userDataSyncMachines';
export class UserDataAutoSyncService extends BaseUserDataAutoSyncService {
constructor(
@IUserDataSyncStoreManagementService userDataSyncStoreManagementService: IUserDataSyncStoreManagementService,
@IUserDataSyncStoreService userDataSyncStoreService: IUserDataSyncStoreService,
@IUserDataSyncResourceEnablementService userDataSyncResourceEnablementService: IUserDataSyncResourceEnablementService,
@IUserDataSyncService userDataSyncService: IUserDataSyncService,
@IUserDataSyncLogService logService: IUserDataSyncLogService,
@IUserDataSyncAccountService authTokenService: IUserDataSyncAccountService,
@IInstantiationService instantiationService: IInstantiationService,
@IHostService hostService: IHostService,
@ITelemetryService telemetryService: ITelemetryService,
@IUserDataSyncMachinesService userDataSyncMachinesService: IUserDataSyncMachinesService,
@IStorageService storageService: IStorageService,
@IEnvironmentService environmentService: IEnvironmentService,
) {
super(userDataSyncStoreManagementService, userDataSyncStoreService, userDataSyncResourceEnablementService, userDataSyncService, logService, authTokenService, telemetryService, userDataSyncMachinesService, storageService, environmentService);
this._register(Event.debounce<string, string[]>(Event.any<string>(
Event.map(hostService.onDidChangeFocus, () => 'windowFocus'),
instantiationService.createInstance(UserDataSyncTrigger).onDidTriggerSync,
), (last, source) => last ? [...last, source] : [source], 1000)(sources => this.triggerSync(sources, true)));
}
}

2
src/vs/workbench/contrib/userDataSync/browser/userDataSync.contribution.ts
View File

@@ -13,6 +13,7 @@ import { Disposable } from 'vs/base/common/lifecycle';
import { localize } from 'vs/nls';
import { isWeb } from 'vs/base/common/platform';
import { IConfigurationService, ConfigurationTarget } from 'vs/platform/configuration/common/configuration';
import { UserDataSyncTrigger } from 'vs/workbench/contrib/userDataSync/browser/userDataSyncTrigger';
class UserDataSyncReportIssueContribution extends Disposable implements IWorkbenchContribution {
@@ -67,6 +68,7 @@ export class UserDataSyncSettingsMigrationContribution implements IWorkbenchCont
const workbenchRegistry = Registry.as<IWorkbenchContributionsRegistry>(WorkbenchExtensions.Workbench);
workbenchRegistry.registerWorkbenchContribution(UserDataSyncWorkbenchContribution, LifecyclePhase.Ready);
workbenchRegistry.registerWorkbenchContribution(UserDataSyncSettingsMigrationContribution, LifecyclePhase.Eventually);
workbenchRegistry.registerWorkbenchContribution(UserDataSyncTrigger, LifecyclePhase.Eventually);
if (isWeb) {
workbenchRegistry.registerWorkbenchContribution(UserDataSyncReportIssueContribution, LifecyclePhase.Ready);

7
src/vs/workbench/contrib/userDataSync/browser/userDataSync.ts
View File

@@ -431,6 +431,9 @@ export class UserDataSyncWorkbenchContribution extends Disposable implements IWo
private async turnOn(): Promise<void> {
try {
if (!this.userDataSyncWorkbenchService.authenticationProviders.length) {
throw new Error(localize('no authentication providers', "No authentication providers are available."));
}
if (!this.storageService.getBoolean('sync.donotAskPreviewConfirmation', StorageScope.GLOBAL, false)) {
if (!await this.askForConfirmation()) {
return;
@@ -478,7 +481,7 @@ export class UserDataSyncWorkbenchContribution extends Disposable implements IWo
return;
}
}
this.notificationService.error(localize('turn on failed', "Error while starting Sync: {0}", toErrorMessage(e)));
this.notificationService.error(localize('turn on failed', "Error while starting Settings Sync: {0}", toErrorMessage(e)));
}
}
@@ -1031,7 +1034,7 @@ export class UserDataSyncWorkbenchContribution extends Disposable implements IWo
});
}
run(accessor: ServicesAccessor): Promise<any> {
return that.userDataAutoSyncService.triggerSync([syncNowCommand.id], false);
return that.userDataAutoSyncService.triggerSync([syncNowCommand.id], false, true);
}
}));
}

34
src/vs/workbench/contrib/userDataSync/browser/userDataSyncTrigger.ts
View File

@@ -3,7 +3,7 @@
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { Event, Emitter } from 'vs/base/common/event';
import { Event } from 'vs/base/common/event';
import { Disposable } from 'vs/base/common/lifecycle';
import { IEditorService } from 'vs/workbench/services/editor/common/editorService';
import { SettingsEditor2Input, KeybindingsEditorInput, PreferencesEditorInput } from 'vs/workbench/services/preferences/common/preferencesEditorInput';
@@ -12,24 +12,36 @@ import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/
import { VIEWLET_ID } from 'vs/workbench/contrib/extensions/common/extensions';
import { IEditorInput } from 'vs/workbench/common/editor';
import { IViewsService } from 'vs/workbench/common/views';
import { IUserDataAutoSyncService } from 'vs/platform/userDataSync/common/userDataSync';
import { IWorkbenchContribution } from 'vs/workbench/common/contributions';
import { isWeb } from 'vs/base/common/platform';
import { IHostService } from 'vs/workbench/services/host/browser/host';
export class UserDataSyncTrigger extends Disposable {
private readonly _onDidTriggerSync: Emitter<string> = this._register(new Emitter<string>());
readonly onDidTriggerSync: Event<string> = this._onDidTriggerSync.event;
export class UserDataSyncTrigger extends Disposable implements IWorkbenchContribution {
constructor(
@IEditorService editorService: IEditorService,
@IWorkbenchEnvironmentService private readonly workbenchEnvironmentService: IWorkbenchEnvironmentService,
@IViewsService viewsService: IViewsService,
@IUserDataAutoSyncService userDataAutoSyncService: IUserDataAutoSyncService,
@IHostService hostService: IHostService,
) {
super();
this._register(
Event.filter(
Event.any<string | undefined>(
Event.map(editorService.onDidActiveEditorChange, () => this.getUserDataEditorInputSource(editorService.activeEditor)),
Event.map(Event.filter(viewsService.onDidChangeViewContainerVisibility, e => e.id === VIEWLET_ID && e.visible), e => e.id)
), source => source !== undefined)(source => this._onDidTriggerSync.fire(source!)));
const event = Event.filter(
Event.any<string | undefined>(
Event.map(editorService.onDidActiveEditorChange, () => this.getUserDataEditorInputSource(editorService.activeEditor)),
Event.map(Event.filter(viewsService.onDidChangeViewContainerVisibility, e => e.id === VIEWLET_ID && e.visible), e => e.id)
), source => source !== undefined);
if (isWeb) {
this._register(Event.debounce<string, string[]>(
Event.any<string>(
Event.map(hostService.onDidChangeFocus, () => 'windowFocus'),
Event.map(event, source => source!),
), (last, source) => last ? [...last, source] : [source], 1000)
(sources => userDataAutoSyncService.triggerSync(sources, true, false)));
} else {
this._register(event(source => userDataAutoSyncService.triggerSync([source!], true, false)));
}
}
private getUserDataEditorInputSource(editorInput: IEditorInput | undefined): string | undefined {

47
src/vs/workbench/contrib/userDataSync/electron-browser/userDataAutoSyncService.ts
View File

@@ -1,47 +0,0 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { IUserDataAutoSyncService, UserDataSyncError, IUserDataSyncStoreManagementService } from 'vs/platform/userDataSync/common/userDataSync';
import { ISharedProcessService } from 'vs/platform/ipc/electron-browser/sharedProcessService';
import { IChannel } from 'vs/base/parts/ipc/common/ipc';
import { Event } from 'vs/base/common/event';
import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
import { UserDataSyncTrigger } from 'vs/workbench/contrib/userDataSync/browser/userDataSyncTrigger';
import { UserDataAutoSyncEnablementService } from 'vs/platform/userDataSync/common/userDataAutoSyncService';
import { IStorageService } from 'vs/platform/storage/common/storage';
import { IEnvironmentService } from 'vs/platform/environment/common/environment';
export class UserDataAutoSyncService extends UserDataAutoSyncEnablementService implements IUserDataAutoSyncService {
declare readonly _serviceBrand: undefined;
private readonly channel: IChannel;
get onError(): Event<UserDataSyncError> { return Event.map(this.channel.listen<Error>('onError'), e => UserDataSyncError.toUserDataSyncError(e)); }
constructor(
@IStorageService storageService: IStorageService,
@IEnvironmentService environmentService: IEnvironmentService,
@IUserDataSyncStoreManagementService userDataSyncStoreManagementService: IUserDataSyncStoreManagementService,
@IInstantiationService instantiationService: IInstantiationService,
@ISharedProcessService sharedProcessService: ISharedProcessService,
) {
super(storageService, environmentService, userDataSyncStoreManagementService);
this.channel = sharedProcessService.getChannel('userDataAutoSync');
this._register(instantiationService.createInstance(UserDataSyncTrigger).onDidTriggerSync(source => this.triggerSync([source], true)));
}
triggerSync(sources: string[], hasToLimitSync: boolean): Promise<void> {
return this.channel.call('triggerSync', [sources, hasToLimitSync]);
}
turnOn(): Promise<void> {
return this.channel.call('turnOn');
}
turnOff(everywhere: boolean): Promise<void> {
return this.channel.call('turnOff', [everywhere]);
}
}

48
src/vs/workbench/contrib/userDataSync/electron-browser/userDataSyncStoreManagementService.ts
View File

@@ -1,48 +0,0 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { IUserDataSyncStoreManagementService, UserDataSyncStoreType, IUserDataSyncStore } from 'vs/platform/userDataSync/common/userDataSync';
import { ISharedProcessService } from 'vs/platform/ipc/electron-browser/sharedProcessService';
import { IChannel } from 'vs/base/parts/ipc/common/ipc';
import { IStorageService } from 'vs/platform/storage/common/storage';
import { AbstractUserDataSyncStoreManagementService } from 'vs/platform/userDataSync/common/userDataSyncStoreService';
import { IProductService } from 'vs/platform/product/common/productService';
import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
import { URI } from 'vs/base/common/uri';
export class UserDataSyncStoreManagementService extends AbstractUserDataSyncStoreManagementService implements IUserDataSyncStoreManagementService {
private readonly channel: IChannel;
constructor(
@IProductService productService: IProductService,
@IConfigurationService configurationService: IConfigurationService,
@IStorageService storageService: IStorageService,
@ISharedProcessService sharedProcessService: ISharedProcessService,
) {
super(productService, configurationService, storageService);
this.channel = sharedProcessService.getChannel('userDataSyncStoreManagement');
}
async switch(type: UserDataSyncStoreType): Promise<void> {
return this.channel.call('switch', [type]);
}
async getPreviousUserDataSyncStore(): Promise<IUserDataSyncStore> {
const userDataSyncStore = await this.channel.call<IUserDataSyncStore>('getPreviousUserDataSyncStore');
return this.revive(userDataSyncStore);
}
private revive(userDataSyncStore: IUserDataSyncStore): IUserDataSyncStore {
return {
url: URI.revive(userDataSyncStore.url),
defaultUrl: URI.revive(userDataSyncStore.defaultUrl),
insidersUrl: URI.revive(userDataSyncStore.insidersUrl),
stableUrl: URI.revive(userDataSyncStore.stableUrl),
authenticationProviders: userDataSyncStore.authenticationProviders,
};
}
}