1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
|
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { Queue } from 'vs/base/common/async';
import { VSBuffer } from 'vs/base/common/buffer';
import { Disposable } from 'vs/base/common/lifecycle';
import { ResourceMap } from 'vs/base/common/map';
import { URI, UriComponents } from 'vs/base/common/uri';
import { Metadata } from 'vs/platform/extensionManagement/common/extensionManagement';
import { areSameExtensions } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
import { IExtension, IExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
import { FileOperationError, FileOperationResult, IFileService } from 'vs/platform/files/common/files';
import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
import { ILogService } from 'vs/platform/log/common/log';
interface IStoredProfileExtension {
identifier: IExtensionIdentifier;
location: UriComponents;
version: string;
metadata?: Metadata;
}
export interface IScannedProfileExtension {
readonly identifier: IExtensionIdentifier;
readonly version: string;
readonly location: URI;
readonly metadata?: Metadata;
}
export const IExtensionsProfileScannerService = createDecorator<IExtensionsProfileScannerService>('IExtensionsProfileScannerService');
export interface IExtensionsProfileScannerService {
readonly _serviceBrand: undefined;
scanProfileExtensions(profileLocation: URI): Promise<IScannedProfileExtension[]>;
addExtensionsToProfile(extensions: [IExtension, Metadata | undefined][], profileLocation: URI): Promise<IScannedProfileExtension[]>;
removeExtensionFromProfile(identifier: IExtensionIdentifier, profileLocation: URI): Promise<IScannedProfileExtension[]>;
}
export class ExtensionsProfileScannerService extends Disposable implements IExtensionsProfileScannerService {
readonly _serviceBrand: undefined;
private readonly resourcesAccessQueueMap = new ResourceMap<Queue<IScannedProfileExtension[]>>();
constructor(
@IFileService private readonly fileService: IFileService,
@ILogService private readonly logService: ILogService,
) {
super();
}
scanProfileExtensions(profileLocation: URI): Promise<IScannedProfileExtension[]> {
return this.withProfileExtensions(profileLocation);
}
addExtensionsToProfile(extensions: [IExtension, Metadata][], profileLocation: URI): Promise<IScannedProfileExtension[]> {
return this.withProfileExtensions(profileLocation, profileExtensions => {
// Remove the existing extension to avoid duplicates
profileExtensions = profileExtensions.filter(e => extensions.some(([extension]) => !areSameExtensions(e.identifier, extension.identifier)));
profileExtensions.push(...extensions.map(([extension, metadata]) => ({ identifier: extension.identifier, version: extension.manifest.version, location: extension.location, metadata })));
return profileExtensions;
});
}
removeExtensionFromProfile(identifier: IExtensionIdentifier, profileLocation: URI): Promise<IScannedProfileExtension[]> {
return this.withProfileExtensions(profileLocation, profileExtensions => profileExtensions.filter(extension => !(areSameExtensions(extension.identifier, identifier))));
}
private async withProfileExtensions(file: URI, updateFn?: (extensions: IScannedProfileExtension[]) => IScannedProfileExtension[]): Promise<IScannedProfileExtension[]> {
return this.getResourceAccessQueue(file).queue(async () => {
let extensions: IScannedProfileExtension[] = [];
// Read
try {
const content = await this.fileService.readFile(file);
const storedWebExtensions: IStoredProfileExtension[] = JSON.parse(content.value.toString());
for (const e of storedWebExtensions) {
if (!e.identifier) {
this.logService.info('Ignoring invalid extension while scanning. Identifier does not exist.', e);
continue;
}
if (!e.location) {
this.logService.info('Ignoring invalid extension while scanning. Location does not exist.', e);
continue;
}
if (!e.version) {
this.logService.info('Ignoring invalid extension while scanning. Version does not exist.', e);
continue;
}
extensions.push({
identifier: e.identifier,
location: URI.revive(e.location),
version: e.version,
metadata: e.metadata,
});
}
} catch (error) {
/* Ignore */
if ((<FileOperationError>error).fileOperationResult !== FileOperationResult.FILE_NOT_FOUND) {
this.logService.error(error);
}
}
// Update
if (updateFn) {
extensions = updateFn(extensions);
const storedProfileExtensions: IStoredProfileExtension[] = extensions.map(e => ({
identifier: e.identifier,
version: e.version,
location: e.location.toJSON(),
metadata: e.metadata
}));
await this.fileService.writeFile(file, VSBuffer.fromString(JSON.stringify(storedProfileExtensions)));
}
return extensions;
});
}
private getResourceAccessQueue(file: URI): Queue<IScannedProfileExtension[]> {
let resourceQueue = this.resourcesAccessQueueMap.get(file);
if (!resourceQueue) {
resourceQueue = new Queue<IScannedProfileExtension[]>();
this.resourcesAccessQueueMap.set(file, resourceQueue);
}
return resourceQueue;
}
}
|
