mirror of
https://github.com/coder/code-server.git
synced 2026-05-29 16:39:33 +00:00
Merge commit 'be3e8236086165e5e45a5a10783823874b3f3ebd' as 'lib/vscode'
This commit is contained in:
Joe Previte
@@ -0,0 +1,114 @@
|
||||
/*---------------------------------------------------------------------------------------------
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
* Licensed under the MIT License. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
|
||||
import { URI } from 'vs/base/common/uri';
|
||||
|
||||
const SshProtocolMatcher = /^([^@:]+@)?([^:]+):/;
|
||||
const SshUrlMatcher = /^([^@:]+@)?([^:]+):(.+)$/;
|
||||
const AuthorityMatcher = /^([^@]+@)?([^:]+)(:\d+)?$/;
|
||||
const SecondLevelDomainMatcher = /([^@:.]+\.[^@:.]+)(:\d+)?$/;
|
||||
const RemoteMatcher = /^\s*url\s*=\s*(.+\S)\s*$/mg;
|
||||
const AnyButDot = /[^.]/g;
|
||||
|
||||
export const AllowedSecondLevelDomains = [
|
||||
'github.com',
|
||||
'bitbucket.org',
|
||||
'visualstudio.com',
|
||||
'gitlab.com',
|
||||
'heroku.com',
|
||||
'azurewebsites.net',
|
||||
'ibm.com',
|
||||
'amazon.com',
|
||||
'amazonaws.com',
|
||||
'cloudapp.net',
|
||||
'rhcloud.com',
|
||||
'google.com',
|
||||
'azure.com'
|
||||
];
|
||||
|
||||
function stripLowLevelDomains(domain: string): string | null {
|
||||
const match = domain.match(SecondLevelDomainMatcher);
|
||||
return match ? match[1] : null;
|
||||
}
|
||||
|
||||
function extractDomain(url: string): string | null {
|
||||
if (url.indexOf('://') === -1) {
|
||||
const match = url.match(SshProtocolMatcher);
|
||||
if (match) {
|
||||
return stripLowLevelDomains(match[2]);
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
try {
|
||||
const uri = URI.parse(url);
|
||||
if (uri.authority) {
|
||||
return stripLowLevelDomains(uri.authority);
|
||||
}
|
||||
} catch (e) {
|
||||
// ignore invalid URIs
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
export function getDomainsOfRemotes(text: string, allowedDomains: readonly string[]): string[] {
|
||||
const domains = new Set<string>();
|
||||
let match: RegExpExecArray | null;
|
||||
while (match = RemoteMatcher.exec(text)) {
|
||||
const domain = extractDomain(match[1]);
|
||||
if (domain) {
|
||||
domains.add(domain);
|
||||
}
|
||||
}
|
||||
|
||||
const allowedDomainsSet = new Set(allowedDomains);
|
||||
return Array.from(domains)
|
||||
.map(key => allowedDomainsSet.has(key) ? key : key.replace(AnyButDot, 'a'));
|
||||
}
|
||||
|
||||
function stripPort(authority: string): string | null {
|
||||
const match = authority.match(AuthorityMatcher);
|
||||
return match ? match[2] : null;
|
||||
}
|
||||
|
||||
function normalizeRemote(host: string | null, path: string, stripEndingDotGit: boolean): string | null {
|
||||
if (host && path) {
|
||||
if (stripEndingDotGit && path.endsWith('.git')) {
|
||||
path = path.substr(0, path.length - 4);
|
||||
}
|
||||
return (path.indexOf('/') === 0) ? `${host}${path}` : `${host}/${path}`;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
function extractRemote(url: string, stripEndingDotGit: boolean): string | null {
|
||||
if (url.indexOf('://') === -1) {
|
||||
const match = url.match(SshUrlMatcher);
|
||||
if (match) {
|
||||
return normalizeRemote(match[2], match[3], stripEndingDotGit);
|
||||
}
|
||||
}
|
||||
try {
|
||||
const uri = URI.parse(url);
|
||||
if (uri.authority) {
|
||||
return normalizeRemote(stripPort(uri.authority), uri.path, stripEndingDotGit);
|
||||
}
|
||||
} catch (e) {
|
||||
// ignore invalid URIs
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
export function getRemotes(text: string, stripEndingDotGit: boolean = false): string[] {
|
||||
const remotes: string[] = [];
|
||||
let match: RegExpExecArray | null;
|
||||
while (match = RemoteMatcher.exec(text)) {
|
||||
const remote = extractRemote(match[1], stripEndingDotGit);
|
||||
if (remote) {
|
||||
remotes.push(remote);
|
||||
}
|
||||
}
|
||||
return remotes;
|
||||
}
|
||||
@@ -0,0 +1,159 @@
|
||||
/*---------------------------------------------------------------------------------------------
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
* Licensed under the MIT License. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
|
||||
import { Event, Emitter } from 'vs/base/common/event';
|
||||
import { Disposable } from 'vs/base/common/lifecycle';
|
||||
import { IExtensionIdentifier, IGlobalExtensionEnablementService, DISABLED_EXTENSIONS_STORAGE_PATH } from 'vs/platform/extensionManagement/common/extensionManagement';
|
||||
import { areSameExtensions } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
|
||||
import { IStorageService, StorageScope, IWorkspaceStorageChangeEvent } from 'vs/platform/storage/common/storage';
|
||||
import { isUndefinedOrNull } from 'vs/base/common/types';
|
||||
|
||||
export class GlobalExtensionEnablementService extends Disposable implements IGlobalExtensionEnablementService {
|
||||
|
||||
declare readonly _serviceBrand: undefined;
|
||||
|
||||
private _onDidChangeEnablement = new Emitter<{ readonly extensions: IExtensionIdentifier[], readonly source?: string }>();
|
||||
readonly onDidChangeEnablement: Event<{ readonly extensions: IExtensionIdentifier[], readonly source?: string }> = this._onDidChangeEnablement.event;
|
||||
private readonly storageManger: StorageManager;
|
||||
|
||||
constructor(
|
||||
@IStorageService storageService: IStorageService,
|
||||
) {
|
||||
super();
|
||||
this.storageManger = this._register(new StorageManager(storageService));
|
||||
this._register(this.storageManger.onDidChange(extensions => this._onDidChangeEnablement.fire({ extensions, source: 'storage' })));
|
||||
}
|
||||
|
||||
async enableExtension(extension: IExtensionIdentifier, source?: string): Promise<boolean> {
|
||||
if (this._removeFromDisabledExtensions(extension)) {
|
||||
this._onDidChangeEnablement.fire({ extensions: [extension], source });
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
async disableExtension(extension: IExtensionIdentifier, source?: string): Promise<boolean> {
|
||||
if (this._addToDisabledExtensions(extension)) {
|
||||
this._onDidChangeEnablement.fire({ extensions: [extension], source });
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
getDisabledExtensions(): IExtensionIdentifier[] {
|
||||
return this._getExtensions(DISABLED_EXTENSIONS_STORAGE_PATH);
|
||||
}
|
||||
|
||||
async getDisabledExtensionsAsync(): Promise<IExtensionIdentifier[]> {
|
||||
return this.getDisabledExtensions();
|
||||
}
|
||||
|
||||
private _addToDisabledExtensions(identifier: IExtensionIdentifier): boolean {
|
||||
let disabledExtensions = this.getDisabledExtensions();
|
||||
if (disabledExtensions.every(e => !areSameExtensions(e, identifier))) {
|
||||
disabledExtensions.push(identifier);
|
||||
this._setDisabledExtensions(disabledExtensions);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private _removeFromDisabledExtensions(identifier: IExtensionIdentifier): boolean {
|
||||
let disabledExtensions = this.getDisabledExtensions();
|
||||
for (let index = 0; index < disabledExtensions.length; index++) {
|
||||
const disabledExtension = disabledExtensions[index];
|
||||
if (areSameExtensions(disabledExtension, identifier)) {
|
||||
disabledExtensions.splice(index, 1);
|
||||
this._setDisabledExtensions(disabledExtensions);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
private _setDisabledExtensions(disabledExtensions: IExtensionIdentifier[]): void {
|
||||
this._setExtensions(DISABLED_EXTENSIONS_STORAGE_PATH, disabledExtensions);
|
||||
}
|
||||
|
||||
private _getExtensions(storageId: string): IExtensionIdentifier[] {
|
||||
return this.storageManger.get(storageId, StorageScope.GLOBAL);
|
||||
}
|
||||
|
||||
private _setExtensions(storageId: string, extensions: IExtensionIdentifier[]): void {
|
||||
this.storageManger.set(storageId, extensions, StorageScope.GLOBAL);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
export class StorageManager extends Disposable {
|
||||
|
||||
private storage: { [key: string]: string } = Object.create(null);
|
||||
|
||||
private _onDidChange: Emitter<IExtensionIdentifier[]> = this._register(new Emitter<IExtensionIdentifier[]>());
|
||||
readonly onDidChange: Event<IExtensionIdentifier[]> = this._onDidChange.event;
|
||||
|
||||
constructor(private storageService: IStorageService) {
|
||||
super();
|
||||
this._register(storageService.onDidChangeStorage(e => this.onDidStorageChange(e)));
|
||||
}
|
||||
|
||||
get(key: string, scope: StorageScope): IExtensionIdentifier[] {
|
||||
let value: string;
|
||||
if (scope === StorageScope.GLOBAL) {
|
||||
if (isUndefinedOrNull(this.storage[key])) {
|
||||
this.storage[key] = this._get(key, scope);
|
||||
}
|
||||
value = this.storage[key];
|
||||
} else {
|
||||
value = this._get(key, scope);
|
||||
}
|
||||
return JSON.parse(value);
|
||||
}
|
||||
|
||||
set(key: string, value: IExtensionIdentifier[], scope: StorageScope): void {
|
||||
let newValue: string = JSON.stringify(value.map(({ id, uuid }) => (<IExtensionIdentifier>{ id, uuid })));
|
||||
const oldValue = this._get(key, scope);
|
||||
if (oldValue !== newValue) {
|
||||
if (scope === StorageScope.GLOBAL) {
|
||||
if (value.length) {
|
||||
this.storage[key] = newValue;
|
||||
} else {
|
||||
delete this.storage[key];
|
||||
}
|
||||
}
|
||||
this._set(key, value.length ? newValue : undefined, scope);
|
||||
}
|
||||
}
|
||||
|
||||
private onDidStorageChange(workspaceStorageChangeEvent: IWorkspaceStorageChangeEvent): void {
|
||||
if (workspaceStorageChangeEvent.scope === StorageScope.GLOBAL) {
|
||||
if (!isUndefinedOrNull(this.storage[workspaceStorageChangeEvent.key])) {
|
||||
const newValue = this._get(workspaceStorageChangeEvent.key, workspaceStorageChangeEvent.scope);
|
||||
if (newValue !== this.storage[workspaceStorageChangeEvent.key]) {
|
||||
const oldValues = this.get(workspaceStorageChangeEvent.key, workspaceStorageChangeEvent.scope);
|
||||
delete this.storage[workspaceStorageChangeEvent.key];
|
||||
const newValues = this.get(workspaceStorageChangeEvent.key, workspaceStorageChangeEvent.scope);
|
||||
const added = oldValues.filter(oldValue => !newValues.some(newValue => areSameExtensions(oldValue, newValue)));
|
||||
const removed = newValues.filter(newValue => !oldValues.some(oldValue => areSameExtensions(oldValue, newValue)));
|
||||
if (added.length || removed.length) {
|
||||
this._onDidChange.fire([...added, ...removed]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private _get(key: string, scope: StorageScope): string {
|
||||
return this.storageService.get(key, scope, '[]');
|
||||
}
|
||||
|
||||
private _set(key: string, value: string | undefined, scope: StorageScope): void {
|
||||
if (value) {
|
||||
this.storageService.store(key, value, scope);
|
||||
} else {
|
||||
this.storageService.remove(key, scope);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,815 @@
|
||||
/*---------------------------------------------------------------------------------------------
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
* Licensed under the MIT License. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
|
||||
import { getErrorMessage, isPromiseCanceledError, canceled } from 'vs/base/common/errors';
|
||||
import { StatisticType, IGalleryExtension, IExtensionGalleryService, IGalleryExtensionAsset, IQueryOptions, SortBy, SortOrder, IExtensionIdentifier, IReportedExtension, InstallOperation, ITranslation, IGalleryExtensionVersion, IGalleryExtensionAssets, isIExtensionIdentifier, DefaultIconPath } from 'vs/platform/extensionManagement/common/extensionManagement';
|
||||
import { getGalleryExtensionId, getGalleryExtensionTelemetryData, adoptToGalleryExtensionId } from 'vs/platform/extensionManagement/common/extensionManagementUtil';
|
||||
import { getOrDefault } from 'vs/base/common/objects';
|
||||
import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
|
||||
import { IPager } from 'vs/base/common/paging';
|
||||
import { IRequestService, asJson, asText } from 'vs/platform/request/common/request';
|
||||
import { IRequestOptions, IRequestContext, IHeaders } from 'vs/base/parts/request/common/request';
|
||||
import { isEngineValid } from 'vs/platform/extensions/common/extensionValidator';
|
||||
import { IEnvironmentService } from 'vs/platform/environment/common/environment';
|
||||
import { CancellationToken } from 'vs/base/common/cancellation';
|
||||
import { ILogService } from 'vs/platform/log/common/log';
|
||||
import { IExtensionManifest } from 'vs/platform/extensions/common/extensions';
|
||||
import { IFileService } from 'vs/platform/files/common/files';
|
||||
import { URI } from 'vs/base/common/uri';
|
||||
import { IProductService } from 'vs/platform/product/common/productService';
|
||||
import { IStorageService, StorageScope } from 'vs/platform/storage/common/storage';
|
||||
import { getServiceMachineId } from 'vs/platform/serviceMachineId/common/serviceMachineId';
|
||||
import { optional } from 'vs/platform/instantiation/common/instantiation';
|
||||
import { joinPath } from 'vs/base/common/resources';
|
||||
|
||||
interface IRawGalleryExtensionFile {
|
||||
assetType: string;
|
||||
source: string;
|
||||
}
|
||||
|
||||
interface IRawGalleryExtensionProperty {
|
||||
key: string;
|
||||
value: string;
|
||||
}
|
||||
|
||||
interface IRawGalleryExtensionVersion {
|
||||
version: string;
|
||||
lastUpdated: string;
|
||||
assetUri: string;
|
||||
fallbackAssetUri: string;
|
||||
files: IRawGalleryExtensionFile[];
|
||||
properties?: IRawGalleryExtensionProperty[];
|
||||
}
|
||||
|
||||
interface IRawGalleryExtensionStatistics {
|
||||
statisticName: string;
|
||||
value: number;
|
||||
}
|
||||
|
||||
interface IRawGalleryExtension {
|
||||
extensionId: string;
|
||||
extensionName: string;
|
||||
displayName: string;
|
||||
shortDescription: string;
|
||||
publisher: { displayName: string, publisherId: string, publisherName: string; };
|
||||
versions: IRawGalleryExtensionVersion[];
|
||||
statistics: IRawGalleryExtensionStatistics[];
|
||||
flags: string;
|
||||
}
|
||||
|
||||
interface IRawGalleryQueryResult {
|
||||
results: {
|
||||
extensions: IRawGalleryExtension[];
|
||||
resultMetadata: {
|
||||
metadataType: string;
|
||||
metadataItems: {
|
||||
name: string;
|
||||
count: number;
|
||||
}[];
|
||||
}[]
|
||||
}[];
|
||||
}
|
||||
|
||||
enum Flags {
|
||||
None = 0x0,
|
||||
IncludeVersions = 0x1,
|
||||
IncludeFiles = 0x2,
|
||||
IncludeCategoryAndTags = 0x4,
|
||||
IncludeSharedAccounts = 0x8,
|
||||
IncludeVersionProperties = 0x10,
|
||||
ExcludeNonValidated = 0x20,
|
||||
IncludeInstallationTargets = 0x40,
|
||||
IncludeAssetUri = 0x80,
|
||||
IncludeStatistics = 0x100,
|
||||
IncludeLatestVersionOnly = 0x200,
|
||||
Unpublished = 0x1000
|
||||
}
|
||||
|
||||
function flagsToString(...flags: Flags[]): string {
|
||||
return String(flags.reduce((r, f) => r | f, 0));
|
||||
}
|
||||
|
||||
enum FilterType {
|
||||
Tag = 1,
|
||||
ExtensionId = 4,
|
||||
Category = 5,
|
||||
ExtensionName = 7,
|
||||
Target = 8,
|
||||
Featured = 9,
|
||||
SearchText = 10,
|
||||
ExcludeWithFlags = 12
|
||||
}
|
||||
|
||||
const AssetType = {
|
||||
Icon: 'Microsoft.VisualStudio.Services.Icons.Default',
|
||||
Details: 'Microsoft.VisualStudio.Services.Content.Details',
|
||||
Changelog: 'Microsoft.VisualStudio.Services.Content.Changelog',
|
||||
Manifest: 'Microsoft.VisualStudio.Code.Manifest',
|
||||
VSIX: 'Microsoft.VisualStudio.Services.VSIXPackage',
|
||||
License: 'Microsoft.VisualStudio.Services.Content.License',
|
||||
Repository: 'Microsoft.VisualStudio.Services.Links.Source'
|
||||
};
|
||||
|
||||
const PropertyType = {
|
||||
Dependency: 'Microsoft.VisualStudio.Code.ExtensionDependencies',
|
||||
ExtensionPack: 'Microsoft.VisualStudio.Code.ExtensionPack',
|
||||
Engine: 'Microsoft.VisualStudio.Code.Engine',
|
||||
LocalizedLanguages: 'Microsoft.VisualStudio.Code.LocalizedLanguages',
|
||||
WebExtension: 'Microsoft.VisualStudio.Code.WebExtension'
|
||||
};
|
||||
|
||||
interface ICriterium {
|
||||
filterType: FilterType;
|
||||
value?: string;
|
||||
}
|
||||
|
||||
const DefaultPageSize = 10;
|
||||
|
||||
interface IQueryState {
|
||||
pageNumber: number;
|
||||
pageSize: number;
|
||||
sortBy: SortBy;
|
||||
sortOrder: SortOrder;
|
||||
flags: Flags;
|
||||
criteria: ICriterium[];
|
||||
assetTypes: string[];
|
||||
}
|
||||
|
||||
const DefaultQueryState: IQueryState = {
|
||||
pageNumber: 1,
|
||||
pageSize: DefaultPageSize,
|
||||
sortBy: SortBy.NoneOrRelevance,
|
||||
sortOrder: SortOrder.Default,
|
||||
flags: Flags.None,
|
||||
criteria: [],
|
||||
assetTypes: []
|
||||
};
|
||||
|
||||
class Query {
|
||||
|
||||
constructor(private state = DefaultQueryState) { }
|
||||
|
||||
get pageNumber(): number { return this.state.pageNumber; }
|
||||
get pageSize(): number { return this.state.pageSize; }
|
||||
get sortBy(): number { return this.state.sortBy; }
|
||||
get sortOrder(): number { return this.state.sortOrder; }
|
||||
get flags(): number { return this.state.flags; }
|
||||
|
||||
withPage(pageNumber: number, pageSize: number = this.state.pageSize): Query {
|
||||
return new Query({ ...this.state, pageNumber, pageSize });
|
||||
}
|
||||
|
||||
withFilter(filterType: FilterType, ...values: string[]): Query {
|
||||
const criteria = [
|
||||
...this.state.criteria,
|
||||
...values.length ? values.map(value => ({ filterType, value })) : [{ filterType }]
|
||||
];
|
||||
|
||||
return new Query({ ...this.state, criteria });
|
||||
}
|
||||
|
||||
withSortBy(sortBy: SortBy): Query {
|
||||
return new Query({ ...this.state, sortBy });
|
||||
}
|
||||
|
||||
withSortOrder(sortOrder: SortOrder): Query {
|
||||
return new Query({ ...this.state, sortOrder });
|
||||
}
|
||||
|
||||
withFlags(...flags: Flags[]): Query {
|
||||
return new Query({ ...this.state, flags: flags.reduce<number>((r, f) => r | f, 0) });
|
||||
}
|
||||
|
||||
withAssetTypes(...assetTypes: string[]): Query {
|
||||
return new Query({ ...this.state, assetTypes });
|
||||
}
|
||||
|
||||
get raw(): any {
|
||||
const { criteria, pageNumber, pageSize, sortBy, sortOrder, flags, assetTypes } = this.state;
|
||||
const filters = [{ criteria, pageNumber, pageSize, sortBy, sortOrder }];
|
||||
return { filters, assetTypes, flags };
|
||||
}
|
||||
|
||||
get searchText(): string {
|
||||
const criterium = this.state.criteria.filter(criterium => criterium.filterType === FilterType.SearchText)[0];
|
||||
return criterium && criterium.value ? criterium.value : '';
|
||||
}
|
||||
}
|
||||
|
||||
function getStatistic(statistics: IRawGalleryExtensionStatistics[], name: string): number {
|
||||
const result = (statistics || []).filter(s => s.statisticName === name)[0];
|
||||
return result ? result.value : 0;
|
||||
}
|
||||
|
||||
function getCoreTranslationAssets(version: IRawGalleryExtensionVersion): [string, IGalleryExtensionAsset][] {
|
||||
const coreTranslationAssetPrefix = 'Microsoft.VisualStudio.Code.Translation.';
|
||||
const result = version.files.filter(f => f.assetType.indexOf(coreTranslationAssetPrefix) === 0);
|
||||
return result.reduce<[string, IGalleryExtensionAsset][]>((result, file) => {
|
||||
const asset = getVersionAsset(version, file.assetType);
|
||||
if (asset) {
|
||||
result.push([file.assetType.substring(coreTranslationAssetPrefix.length), asset]);
|
||||
}
|
||||
return result;
|
||||
}, []);
|
||||
}
|
||||
|
||||
function getRepositoryAsset(version: IRawGalleryExtensionVersion): IGalleryExtensionAsset | null {
|
||||
if (version.properties) {
|
||||
const results = version.properties.filter(p => p.key === AssetType.Repository);
|
||||
const gitRegExp = new RegExp('((git|ssh|http(s)?)|(git@[\w.]+))(:(//)?)([\w.@\:/\-~]+)(.git)(/)?');
|
||||
|
||||
const uri = results.filter(r => gitRegExp.test(r.value))[0];
|
||||
return uri ? { uri: uri.value, fallbackUri: uri.value } : null;
|
||||
}
|
||||
return getVersionAsset(version, AssetType.Repository);
|
||||
}
|
||||
|
||||
function getDownloadAsset(version: IRawGalleryExtensionVersion): IGalleryExtensionAsset {
|
||||
return {
|
||||
uri: `${version.fallbackAssetUri}/${AssetType.VSIX}?redirect=true`,
|
||||
fallbackUri: `${version.fallbackAssetUri}/${AssetType.VSIX}`
|
||||
};
|
||||
}
|
||||
|
||||
function getIconAsset(version: IRawGalleryExtensionVersion): IGalleryExtensionAsset {
|
||||
const asset = getVersionAsset(version, AssetType.Icon);
|
||||
if (asset) {
|
||||
return asset;
|
||||
}
|
||||
const uri = DefaultIconPath;
|
||||
return { uri, fallbackUri: uri };
|
||||
}
|
||||
|
||||
function getVersionAsset(version: IRawGalleryExtensionVersion, type: string): IGalleryExtensionAsset | null {
|
||||
const result = version.files.filter(f => f.assetType === type)[0];
|
||||
return result ? { uri: `${version.assetUri}/${type}`, fallbackUri: `${version.fallbackAssetUri}/${type}` } : null;
|
||||
}
|
||||
|
||||
function getExtensions(version: IRawGalleryExtensionVersion, property: string): string[] {
|
||||
const values = version.properties ? version.properties.filter(p => p.key === property) : [];
|
||||
const value = values.length > 0 && values[0].value;
|
||||
return value ? value.split(',').map(v => adoptToGalleryExtensionId(v)) : [];
|
||||
}
|
||||
|
||||
function getEngine(version: IRawGalleryExtensionVersion): string {
|
||||
const values = version.properties ? version.properties.filter(p => p.key === PropertyType.Engine) : [];
|
||||
return (values.length > 0 && values[0].value) || '';
|
||||
}
|
||||
|
||||
function getLocalizedLanguages(version: IRawGalleryExtensionVersion): string[] {
|
||||
const values = version.properties ? version.properties.filter(p => p.key === PropertyType.LocalizedLanguages) : [];
|
||||
const value = (values.length > 0 && values[0].value) || '';
|
||||
return value ? value.split(',') : [];
|
||||
}
|
||||
|
||||
function getIsPreview(flags: string): boolean {
|
||||
return flags.indexOf('preview') !== -1;
|
||||
}
|
||||
|
||||
function getIsWebExtension(version: IRawGalleryExtensionVersion): boolean {
|
||||
const webExtensionProperty = version.properties ? version.properties.find(p => p.key === PropertyType.WebExtension) : undefined;
|
||||
return !!webExtensionProperty && webExtensionProperty.value === 'true';
|
||||
}
|
||||
|
||||
function getWebResource(version: IRawGalleryExtensionVersion): URI | undefined {
|
||||
return version.files.some(f => f.assetType.startsWith('Microsoft.VisualStudio.Code.WebResources'))
|
||||
? joinPath(URI.parse(version.assetUri), 'Microsoft.VisualStudio.Code.WebResources', 'extension')
|
||||
: undefined;
|
||||
}
|
||||
|
||||
function toExtension(galleryExtension: IRawGalleryExtension, version: IRawGalleryExtensionVersion, index: number, query: Query, querySource?: string): IGalleryExtension {
|
||||
const assets = <IGalleryExtensionAssets>{
|
||||
manifest: getVersionAsset(version, AssetType.Manifest),
|
||||
readme: getVersionAsset(version, AssetType.Details),
|
||||
changelog: getVersionAsset(version, AssetType.Changelog),
|
||||
license: getVersionAsset(version, AssetType.License),
|
||||
repository: getRepositoryAsset(version),
|
||||
download: getDownloadAsset(version),
|
||||
icon: getIconAsset(version),
|
||||
coreTranslations: getCoreTranslationAssets(version)
|
||||
};
|
||||
|
||||
return {
|
||||
identifier: {
|
||||
id: getGalleryExtensionId(galleryExtension.publisher.publisherName, galleryExtension.extensionName),
|
||||
uuid: galleryExtension.extensionId
|
||||
},
|
||||
name: galleryExtension.extensionName,
|
||||
version: version.version,
|
||||
date: version.lastUpdated,
|
||||
displayName: galleryExtension.displayName,
|
||||
publisherId: galleryExtension.publisher.publisherId,
|
||||
publisher: galleryExtension.publisher.publisherName,
|
||||
publisherDisplayName: galleryExtension.publisher.displayName,
|
||||
description: galleryExtension.shortDescription || '',
|
||||
installCount: getStatistic(galleryExtension.statistics, 'install'),
|
||||
rating: getStatistic(galleryExtension.statistics, 'averagerating'),
|
||||
ratingCount: getStatistic(galleryExtension.statistics, 'ratingcount'),
|
||||
assetUri: URI.parse(version.assetUri),
|
||||
webResource: getWebResource(version),
|
||||
assetTypes: version.files.map(({ assetType }) => assetType),
|
||||
assets,
|
||||
properties: {
|
||||
dependencies: getExtensions(version, PropertyType.Dependency),
|
||||
extensionPack: getExtensions(version, PropertyType.ExtensionPack),
|
||||
engine: getEngine(version),
|
||||
localizedLanguages: getLocalizedLanguages(version),
|
||||
webExtension: getIsWebExtension(version)
|
||||
},
|
||||
/* __GDPR__FRAGMENT__
|
||||
"GalleryExtensionTelemetryData2" : {
|
||||
"index" : { "classification": "SystemMetaData", "purpose": "FeatureInsight", "isMeasurement": true },
|
||||
"searchText": { "classification": "CustomerContent", "purpose": "FeatureInsight" },
|
||||
"querySource": { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
|
||||
}
|
||||
*/
|
||||
telemetryData: {
|
||||
index: ((query.pageNumber - 1) * query.pageSize) + index,
|
||||
searchText: query.searchText,
|
||||
querySource
|
||||
},
|
||||
preview: getIsPreview(galleryExtension.flags)
|
||||
};
|
||||
}
|
||||
|
||||
interface IRawExtensionsReport {
|
||||
malicious: string[];
|
||||
slow: string[];
|
||||
}
|
||||
|
||||
export class ExtensionGalleryService implements IExtensionGalleryService {
|
||||
|
||||
declare readonly _serviceBrand: undefined;
|
||||
|
||||
private extensionsGalleryUrl: string | undefined;
|
||||
private extensionsControlUrl: string | undefined;
|
||||
|
||||
private readonly commonHeadersPromise: Promise<{ [key: string]: string; }>;
|
||||
|
||||
constructor(
|
||||
@IRequestService private readonly requestService: IRequestService,
|
||||
@ILogService private readonly logService: ILogService,
|
||||
@IEnvironmentService private readonly environmentService: IEnvironmentService,
|
||||
@ITelemetryService private readonly telemetryService: ITelemetryService,
|
||||
@IFileService private readonly fileService: IFileService,
|
||||
@IProductService private readonly productService: IProductService,
|
||||
@optional(IStorageService) storageService: IStorageService,
|
||||
) {
|
||||
const config = productService.extensionsGallery;
|
||||
this.extensionsGalleryUrl = config && config.serviceUrl;
|
||||
this.extensionsControlUrl = config && config.controlUrl;
|
||||
this.commonHeadersPromise = resolveMarketplaceHeaders(productService.version, this.environmentService, this.fileService, storageService);
|
||||
}
|
||||
|
||||
private api(path = ''): string {
|
||||
return `${this.extensionsGalleryUrl}${path}`;
|
||||
}
|
||||
|
||||
isEnabled(): boolean {
|
||||
return !!this.extensionsGalleryUrl;
|
||||
}
|
||||
|
||||
async getExtensions(names: string[], token: CancellationToken): Promise<IGalleryExtension[]> {
|
||||
const result: IGalleryExtension[] = [];
|
||||
let { total, firstPage: pageResult, getPage } = await this.query({ names, pageSize: names.length }, token);
|
||||
result.push(...pageResult);
|
||||
for (let pageIndex = 1; result.length < total; pageIndex++) {
|
||||
pageResult = await getPage(pageIndex, token);
|
||||
if (pageResult.length) {
|
||||
result.push(...pageResult);
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
async getCompatibleExtension(arg1: IExtensionIdentifier | IGalleryExtension, version?: string): Promise<IGalleryExtension | null> {
|
||||
const extension = await this.getCompatibleExtensionByEngine(arg1, version);
|
||||
|
||||
if (extension?.properties.webExtension) {
|
||||
return extension.webResource ? extension : null;
|
||||
} else {
|
||||
return extension;
|
||||
}
|
||||
}
|
||||
|
||||
private async getCompatibleExtensionByEngine(arg1: IExtensionIdentifier | IGalleryExtension, version?: string): Promise<IGalleryExtension | null> {
|
||||
const extension: IGalleryExtension | null = isIExtensionIdentifier(arg1) ? null : arg1;
|
||||
if (extension && extension.properties.engine && isEngineValid(extension.properties.engine, this.productService.version)) {
|
||||
return extension;
|
||||
}
|
||||
const { id, uuid } = extension ? extension.identifier : <IExtensionIdentifier>arg1;
|
||||
let query = new Query()
|
||||
.withFlags(Flags.IncludeAssetUri, Flags.IncludeStatistics, Flags.IncludeFiles, Flags.IncludeVersionProperties)
|
||||
.withPage(1, 1)
|
||||
.withFilter(FilterType.Target, 'Microsoft.VisualStudio.Code');
|
||||
|
||||
if (uuid) {
|
||||
query = query.withFilter(FilterType.ExtensionId, uuid);
|
||||
} else {
|
||||
query = query.withFilter(FilterType.ExtensionName, id);
|
||||
}
|
||||
|
||||
const { galleryExtensions } = await this.queryGallery(query, CancellationToken.None);
|
||||
const [rawExtension] = galleryExtensions;
|
||||
if (!rawExtension || !rawExtension.versions.length) {
|
||||
return null;
|
||||
}
|
||||
|
||||
if (version) {
|
||||
const versionAsset = rawExtension.versions.filter(v => v.version === version)[0];
|
||||
if (versionAsset) {
|
||||
const extension = toExtension(rawExtension, versionAsset, 0, query);
|
||||
if (extension.properties.engine && isEngineValid(extension.properties.engine, this.productService.version)) {
|
||||
return extension;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
const rawVersion = await this.getLastValidExtensionVersion(rawExtension, rawExtension.versions);
|
||||
if (rawVersion) {
|
||||
return toExtension(rawExtension, rawVersion, 0, query);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
query(token: CancellationToken): Promise<IPager<IGalleryExtension>>;
|
||||
query(options: IQueryOptions, token: CancellationToken): Promise<IPager<IGalleryExtension>>;
|
||||
async query(arg1: any, arg2?: any): Promise<IPager<IGalleryExtension>> {
|
||||
const options: IQueryOptions = CancellationToken.isCancellationToken(arg1) ? {} : arg1;
|
||||
const token: CancellationToken = CancellationToken.isCancellationToken(arg1) ? arg1 : arg2;
|
||||
|
||||
if (!this.isEnabled()) {
|
||||
throw new Error('No extension gallery service configured.');
|
||||
}
|
||||
|
||||
const type = options.names ? 'ids' : (options.text ? 'text' : 'all');
|
||||
let text = options.text || '';
|
||||
const pageSize = getOrDefault(options, o => o.pageSize, 50);
|
||||
|
||||
type GalleryServiceQueryClassification = {
|
||||
type: { classification: 'SystemMetaData', purpose: 'FeatureInsight' };
|
||||
text: { classification: 'CustomerContent', purpose: 'FeatureInsight' };
|
||||
};
|
||||
type GalleryServiceQueryEvent = {
|
||||
type: string;
|
||||
text: string;
|
||||
};
|
||||
this.telemetryService.publicLog2<GalleryServiceQueryEvent, GalleryServiceQueryClassification>('galleryService:query', { type, text });
|
||||
|
||||
let query = new Query()
|
||||
.withFlags(Flags.IncludeLatestVersionOnly, Flags.IncludeAssetUri, Flags.IncludeStatistics, Flags.IncludeFiles, Flags.IncludeVersionProperties)
|
||||
.withPage(1, pageSize)
|
||||
.withFilter(FilterType.Target, 'Microsoft.VisualStudio.Code');
|
||||
|
||||
if (text) {
|
||||
// Use category filter instead of "category:themes"
|
||||
text = text.replace(/\bcategory:("([^"]*)"|([^"]\S*))(\s+|\b|$)/g, (_, quotedCategory, category) => {
|
||||
query = query.withFilter(FilterType.Category, category || quotedCategory);
|
||||
return '';
|
||||
});
|
||||
|
||||
// Use tag filter instead of "tag:debuggers"
|
||||
text = text.replace(/\btag:("([^"]*)"|([^"]\S*))(\s+|\b|$)/g, (_, quotedTag, tag) => {
|
||||
query = query.withFilter(FilterType.Tag, tag || quotedTag);
|
||||
return '';
|
||||
});
|
||||
|
||||
// Use featured filter
|
||||
text = text.replace(/\bfeatured(\s+|\b|$)/g, () => {
|
||||
query = query.withFilter(FilterType.Featured);
|
||||
return '';
|
||||
});
|
||||
|
||||
text = text.trim();
|
||||
|
||||
if (text) {
|
||||
text = text.length < 200 ? text : text.substring(0, 200);
|
||||
query = query.withFilter(FilterType.SearchText, text);
|
||||
}
|
||||
|
||||
query = query.withSortBy(SortBy.NoneOrRelevance);
|
||||
} else if (options.ids) {
|
||||
query = query.withFilter(FilterType.ExtensionId, ...options.ids);
|
||||
} else if (options.names) {
|
||||
query = query.withFilter(FilterType.ExtensionName, ...options.names);
|
||||
} else {
|
||||
query = query.withSortBy(SortBy.InstallCount);
|
||||
}
|
||||
|
||||
if (typeof options.sortBy === 'number') {
|
||||
query = query.withSortBy(options.sortBy);
|
||||
}
|
||||
|
||||
if (typeof options.sortOrder === 'number') {
|
||||
query = query.withSortOrder(options.sortOrder);
|
||||
}
|
||||
|
||||
const { galleryExtensions, total } = await this.queryGallery(query, token);
|
||||
const extensions = galleryExtensions.map((e, index) => toExtension(e, e.versions[0], index, query, options.source));
|
||||
const getPage = async (pageIndex: number, ct: CancellationToken) => {
|
||||
if (ct.isCancellationRequested) {
|
||||
throw canceled();
|
||||
}
|
||||
const nextPageQuery = query.withPage(pageIndex + 1);
|
||||
const { galleryExtensions } = await this.queryGallery(nextPageQuery, ct);
|
||||
return galleryExtensions.map((e, index) => toExtension(e, e.versions[0], index, nextPageQuery, options.source));
|
||||
};
|
||||
|
||||
return { firstPage: extensions, total, pageSize: query.pageSize, getPage } as IPager<IGalleryExtension>;
|
||||
}
|
||||
|
||||
private async queryGallery(query: Query, token: CancellationToken): Promise<{ galleryExtensions: IRawGalleryExtension[], total: number; }> {
|
||||
if (!this.isEnabled()) {
|
||||
throw new Error('No extension gallery service configured.');
|
||||
}
|
||||
|
||||
// Always exclude non validated and unpublished extensions
|
||||
query = query
|
||||
.withFlags(query.flags, Flags.ExcludeNonValidated)
|
||||
.withFilter(FilterType.ExcludeWithFlags, flagsToString(Flags.Unpublished));
|
||||
|
||||
const commonHeaders = await this.commonHeadersPromise;
|
||||
const data = JSON.stringify(query.raw);
|
||||
const headers = {
|
||||
...commonHeaders,
|
||||
'Content-Type': 'application/json',
|
||||
'Accept': 'application/json;api-version=3.0-preview.1',
|
||||
'Accept-Encoding': 'gzip',
|
||||
'Content-Length': String(data.length)
|
||||
};
|
||||
|
||||
const context = await this.requestService.request({
|
||||
type: 'POST',
|
||||
url: this.api('/extensionquery'),
|
||||
data,
|
||||
headers
|
||||
}, token);
|
||||
|
||||
if (context.res.statusCode && context.res.statusCode >= 400 && context.res.statusCode < 500) {
|
||||
return { galleryExtensions: [], total: 0 };
|
||||
}
|
||||
|
||||
const result = await asJson<IRawGalleryQueryResult>(context);
|
||||
if (result) {
|
||||
const r = result.results[0];
|
||||
const galleryExtensions = r.extensions;
|
||||
const resultCount = r.resultMetadata && r.resultMetadata.filter(m => m.metadataType === 'ResultCount')[0];
|
||||
const total = resultCount && resultCount.metadataItems.filter(i => i.name === 'TotalCount')[0].count || 0;
|
||||
|
||||
return { galleryExtensions, total };
|
||||
}
|
||||
return { galleryExtensions: [], total: 0 };
|
||||
}
|
||||
|
||||
async reportStatistic(publisher: string, name: string, version: string, type: StatisticType): Promise<void> {
|
||||
if (!this.isEnabled()) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
const commonHeaders = await this.commonHeadersPromise;
|
||||
const headers = { ...commonHeaders, Accept: '*/*;api-version=4.0-preview.1' };
|
||||
try {
|
||||
await this.requestService.request({
|
||||
type: 'POST',
|
||||
url: this.api(`/publishers/${publisher}/extensions/${name}/${version}/stats?statType=${type}`),
|
||||
headers
|
||||
}, CancellationToken.None);
|
||||
} catch (error) { /* Ignore */ }
|
||||
}
|
||||
|
||||
async download(extension: IGalleryExtension, location: URI, operation: InstallOperation): Promise<void> {
|
||||
this.logService.trace('ExtensionGalleryService#download', extension.identifier.id);
|
||||
const data = getGalleryExtensionTelemetryData(extension);
|
||||
const startTime = new Date().getTime();
|
||||
/* __GDPR__
|
||||
"galleryService:downloadVSIX" : {
|
||||
"duration": { "classification": "SystemMetaData", "purpose": "PerformanceAndHealth", "isMeasurement": true },
|
||||
"${include}": [
|
||||
"${GalleryExtensionTelemetryData}"
|
||||
]
|
||||
}
|
||||
*/
|
||||
const log = (duration: number) => this.telemetryService.publicLog('galleryService:downloadVSIX', { ...data, duration });
|
||||
|
||||
const operationParam = operation === InstallOperation.Install ? 'install' : operation === InstallOperation.Update ? 'update' : '';
|
||||
const downloadAsset = operationParam ? {
|
||||
uri: `${extension.assets.download.uri}&${operationParam}=true`,
|
||||
fallbackUri: `${extension.assets.download.fallbackUri}?${operationParam}=true`
|
||||
} : extension.assets.download;
|
||||
|
||||
const context = await this.getAsset(downloadAsset);
|
||||
await this.fileService.writeFile(location, context.stream);
|
||||
log(new Date().getTime() - startTime);
|
||||
}
|
||||
|
||||
async getReadme(extension: IGalleryExtension, token: CancellationToken): Promise<string> {
|
||||
if (extension.assets.readme) {
|
||||
const context = await this.getAsset(extension.assets.readme, {}, token);
|
||||
const content = await asText(context);
|
||||
return content || '';
|
||||
}
|
||||
return '';
|
||||
}
|
||||
|
||||
async getManifest(extension: IGalleryExtension, token: CancellationToken): Promise<IExtensionManifest | null> {
|
||||
if (extension.assets.manifest) {
|
||||
const context = await this.getAsset(extension.assets.manifest, {}, token);
|
||||
const text = await asText(context);
|
||||
return text ? JSON.parse(text) : null;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
async getCoreTranslation(extension: IGalleryExtension, languageId: string): Promise<ITranslation | null> {
|
||||
const asset = extension.assets.coreTranslations.filter(t => t[0] === languageId.toUpperCase())[0];
|
||||
if (asset) {
|
||||
const context = await this.getAsset(asset[1]);
|
||||
const text = await asText(context);
|
||||
return text ? JSON.parse(text) : null;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
async getChangelog(extension: IGalleryExtension, token: CancellationToken): Promise<string> {
|
||||
if (extension.assets.changelog) {
|
||||
const context = await this.getAsset(extension.assets.changelog, {}, token);
|
||||
const content = await asText(context);
|
||||
return content || '';
|
||||
}
|
||||
return '';
|
||||
}
|
||||
|
||||
async getAllVersions(extension: IGalleryExtension, compatible: boolean): Promise<IGalleryExtensionVersion[]> {
|
||||
let query = new Query()
|
||||
.withFlags(Flags.IncludeVersions, Flags.IncludeFiles, Flags.IncludeVersionProperties)
|
||||
.withPage(1, 1)
|
||||
.withFilter(FilterType.Target, 'Microsoft.VisualStudio.Code');
|
||||
|
||||
if (extension.identifier.uuid) {
|
||||
query = query.withFilter(FilterType.ExtensionId, extension.identifier.uuid);
|
||||
} else {
|
||||
query = query.withFilter(FilterType.ExtensionName, extension.identifier.id);
|
||||
}
|
||||
|
||||
const result: IGalleryExtensionVersion[] = [];
|
||||
const { galleryExtensions } = await this.queryGallery(query, CancellationToken.None);
|
||||
if (galleryExtensions.length) {
|
||||
if (compatible) {
|
||||
await Promise.all(galleryExtensions[0].versions.map(async v => {
|
||||
let engine: string | undefined;
|
||||
try {
|
||||
engine = await this.getEngine(v);
|
||||
} catch (error) { /* Ignore error and skip version */ }
|
||||
if (engine && isEngineValid(engine, this.productService.version)) {
|
||||
result.push({ version: v!.version, date: v!.lastUpdated });
|
||||
}
|
||||
}));
|
||||
} else {
|
||||
result.push(...galleryExtensions[0].versions.map(v => ({ version: v.version, date: v.lastUpdated })));
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
private async getAsset(asset: IGalleryExtensionAsset, options: IRequestOptions = {}, token: CancellationToken = CancellationToken.None): Promise<IRequestContext> {
|
||||
const commonHeaders = await this.commonHeadersPromise;
|
||||
const baseOptions = { type: 'GET' };
|
||||
const headers = { ...commonHeaders, ...(options.headers || {}) };
|
||||
options = { ...options, ...baseOptions, headers };
|
||||
|
||||
const url = asset.uri;
|
||||
const fallbackUrl = asset.fallbackUri;
|
||||
const firstOptions = { ...options, url };
|
||||
|
||||
try {
|
||||
const context = await this.requestService.request(firstOptions, token);
|
||||
if (context.res.statusCode === 200) {
|
||||
return context;
|
||||
}
|
||||
const message = await asText(context);
|
||||
throw new Error(`Expected 200, got back ${context.res.statusCode} instead.\n\n${message}`);
|
||||
} catch (err) {
|
||||
if (isPromiseCanceledError(err)) {
|
||||
throw err;
|
||||
}
|
||||
|
||||
const message = getErrorMessage(err);
|
||||
type GalleryServiceCDNFallbackClassification = {
|
||||
url: { classification: 'SystemMetaData', purpose: 'FeatureInsight' };
|
||||
message: { classification: 'SystemMetaData', purpose: 'FeatureInsight' };
|
||||
};
|
||||
type GalleryServiceCDNFallbackEvent = {
|
||||
url: string;
|
||||
message: string;
|
||||
};
|
||||
this.telemetryService.publicLog2<GalleryServiceCDNFallbackEvent, GalleryServiceCDNFallbackClassification>('galleryService:cdnFallback', { url, message });
|
||||
|
||||
const fallbackOptions = { ...options, url: fallbackUrl };
|
||||
return this.requestService.request(fallbackOptions, token);
|
||||
}
|
||||
}
|
||||
|
||||
private async getLastValidExtensionVersion(extension: IRawGalleryExtension, versions: IRawGalleryExtensionVersion[]): Promise<IRawGalleryExtensionVersion | null> {
|
||||
const version = this.getLastValidExtensionVersionFromProperties(extension, versions);
|
||||
if (version) {
|
||||
return version;
|
||||
}
|
||||
return this.getLastValidExtensionVersionRecursively(extension, versions);
|
||||
}
|
||||
|
||||
private getLastValidExtensionVersionFromProperties(extension: IRawGalleryExtension, versions: IRawGalleryExtensionVersion[]): IRawGalleryExtensionVersion | null {
|
||||
for (const version of versions) {
|
||||
const engine = getEngine(version);
|
||||
if (!engine) {
|
||||
return null;
|
||||
}
|
||||
if (isEngineValid(engine, this.productService.version)) {
|
||||
return version;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private async getEngine(version: IRawGalleryExtensionVersion): Promise<string> {
|
||||
const engine = getEngine(version);
|
||||
if (engine) {
|
||||
return engine;
|
||||
}
|
||||
|
||||
const manifestAsset = getVersionAsset(version, AssetType.Manifest);
|
||||
if (!manifestAsset) {
|
||||
throw new Error('Manifest was not found');
|
||||
}
|
||||
|
||||
const headers = { 'Accept-Encoding': 'gzip' };
|
||||
const context = await this.getAsset(manifestAsset, { headers });
|
||||
const manifest = await asJson<IExtensionManifest>(context);
|
||||
if (manifest) {
|
||||
return manifest.engines.vscode;
|
||||
}
|
||||
|
||||
throw new Error('Error while reading manifest');
|
||||
}
|
||||
|
||||
private async getLastValidExtensionVersionRecursively(extension: IRawGalleryExtension, versions: IRawGalleryExtensionVersion[]): Promise<IRawGalleryExtensionVersion | null> {
|
||||
if (!versions.length) {
|
||||
return null;
|
||||
}
|
||||
|
||||
const version = versions[0];
|
||||
const engine = await this.getEngine(version);
|
||||
if (!isEngineValid(engine, this.productService.version)) {
|
||||
return this.getLastValidExtensionVersionRecursively(extension, versions.slice(1));
|
||||
}
|
||||
|
||||
version.properties = version.properties || [];
|
||||
version.properties.push({ key: PropertyType.Engine, value: engine });
|
||||
return version;
|
||||
}
|
||||
|
||||
async getExtensionsReport(): Promise<IReportedExtension[]> {
|
||||
if (!this.isEnabled()) {
|
||||
throw new Error('No extension gallery service configured.');
|
||||
}
|
||||
|
||||
if (!this.extensionsControlUrl) {
|
||||
return [];
|
||||
}
|
||||
|
||||
const context = await this.requestService.request({ type: 'GET', url: this.extensionsControlUrl }, CancellationToken.None);
|
||||
if (context.res.statusCode !== 200) {
|
||||
throw new Error('Could not get extensions report.');
|
||||
}
|
||||
|
||||
const result = await asJson<IRawExtensionsReport>(context);
|
||||
const map = new Map<string, IReportedExtension>();
|
||||
|
||||
if (result) {
|
||||
for (const id of result.malicious) {
|
||||
const ext = map.get(id) || { id: { id }, malicious: true, slow: false };
|
||||
ext.malicious = true;
|
||||
map.set(id, ext);
|
||||
}
|
||||
}
|
||||
|
||||
return [...map.values()];
|
||||
}
|
||||
}
|
||||
|
||||
export async function resolveMarketplaceHeaders(version: string, environmentService: IEnvironmentService, fileService: IFileService, storageService: {
|
||||
get: (key: string, scope: StorageScope) => string | undefined,
|
||||
store: (key: string, value: string, scope: StorageScope) => void
|
||||
} | undefined): Promise<{ [key: string]: string; }> {
|
||||
const headers: IHeaders = {
|
||||
'X-Market-Client-Id': `VSCode ${version}`,
|
||||
'User-Agent': `VSCode ${version}`
|
||||
};
|
||||
const uuid = await getServiceMachineId(environmentService, fileService, storageService);
|
||||
headers['X-Market-User-Id'] = uuid;
|
||||
return headers;
|
||||
}
|
||||
@@ -0,0 +1,279 @@
|
||||
/*---------------------------------------------------------------------------------------------
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
* Licensed under the MIT License. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
|
||||
import { localize } from 'vs/nls';
|
||||
import { Event } from 'vs/base/common/event';
|
||||
import { IPager } from 'vs/base/common/paging';
|
||||
import { createDecorator } from 'vs/platform/instantiation/common/instantiation';
|
||||
import { URI } from 'vs/base/common/uri';
|
||||
import { CancellationToken } from 'vs/base/common/cancellation';
|
||||
import { IExtensionManifest, IExtension, ExtensionType } from 'vs/platform/extensions/common/extensions';
|
||||
import { FileAccess } from 'vs/base/common/network';
|
||||
|
||||
export const EXTENSION_IDENTIFIER_PATTERN = '^([a-z0-9A-Z][a-z0-9-A-Z]*)\\.([a-z0-9A-Z][a-z0-9-A-Z]*)$';
|
||||
export const EXTENSION_IDENTIFIER_REGEX = new RegExp(EXTENSION_IDENTIFIER_PATTERN);
|
||||
|
||||
export interface IGalleryExtensionProperties {
|
||||
dependencies?: string[];
|
||||
extensionPack?: string[];
|
||||
engine?: string;
|
||||
localizedLanguages?: string[];
|
||||
webExtension?: boolean;
|
||||
}
|
||||
|
||||
export interface IGalleryExtensionAsset {
|
||||
uri: string;
|
||||
fallbackUri: string;
|
||||
}
|
||||
|
||||
export interface IGalleryExtensionAssets {
|
||||
manifest: IGalleryExtensionAsset | null;
|
||||
readme: IGalleryExtensionAsset | null;
|
||||
changelog: IGalleryExtensionAsset | null;
|
||||
license: IGalleryExtensionAsset | null;
|
||||
repository: IGalleryExtensionAsset | null;
|
||||
download: IGalleryExtensionAsset;
|
||||
icon: IGalleryExtensionAsset;
|
||||
coreTranslations: [string, IGalleryExtensionAsset][];
|
||||
}
|
||||
|
||||
export function isIExtensionIdentifier(thing: any): thing is IExtensionIdentifier {
|
||||
return thing
|
||||
&& typeof thing === 'object'
|
||||
&& typeof thing.id === 'string'
|
||||
&& (!thing.uuid || typeof thing.uuid === 'string');
|
||||
}
|
||||
|
||||
/* __GDPR__FRAGMENT__
|
||||
"ExtensionIdentifier" : {
|
||||
"id" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
|
||||
"uuid": { "classification": "SystemMetaData", "purpose": "FeatureInsight" }
|
||||
}
|
||||
*/
|
||||
export interface IExtensionIdentifier {
|
||||
id: string;
|
||||
uuid?: string;
|
||||
}
|
||||
|
||||
export interface IExtensionIdentifierWithVersion extends IExtensionIdentifier {
|
||||
id: string;
|
||||
uuid?: string;
|
||||
version: string;
|
||||
}
|
||||
|
||||
export interface IGalleryExtensionIdentifier extends IExtensionIdentifier {
|
||||
uuid: string;
|
||||
}
|
||||
|
||||
export interface IGalleryExtensionVersion {
|
||||
version: string;
|
||||
date: string;
|
||||
}
|
||||
|
||||
export interface IGalleryExtension {
|
||||
name: string;
|
||||
identifier: IGalleryExtensionIdentifier;
|
||||
version: string;
|
||||
date: string;
|
||||
displayName: string;
|
||||
publisherId: string;
|
||||
publisher: string;
|
||||
publisherDisplayName: string;
|
||||
description: string;
|
||||
installCount: number;
|
||||
rating: number;
|
||||
ratingCount: number;
|
||||
assetUri: URI;
|
||||
assetTypes: string[];
|
||||
assets: IGalleryExtensionAssets;
|
||||
properties: IGalleryExtensionProperties;
|
||||
telemetryData: any;
|
||||
preview: boolean;
|
||||
webResource?: URI;
|
||||
}
|
||||
|
||||
export interface IGalleryMetadata {
|
||||
id: string;
|
||||
publisherId: string;
|
||||
publisherDisplayName: string;
|
||||
}
|
||||
|
||||
export interface ILocalExtension extends IExtension {
|
||||
isMachineScoped: boolean;
|
||||
publisherId: string | null;
|
||||
publisherDisplayName: string | null;
|
||||
}
|
||||
|
||||
export const enum SortBy {
|
||||
NoneOrRelevance = 0,
|
||||
LastUpdatedDate = 1,
|
||||
Title = 2,
|
||||
PublisherName = 3,
|
||||
InstallCount = 4,
|
||||
PublishedDate = 5,
|
||||
AverageRating = 6,
|
||||
WeightedRating = 12
|
||||
}
|
||||
|
||||
export const enum SortOrder {
|
||||
Default = 0,
|
||||
Ascending = 1,
|
||||
Descending = 2
|
||||
}
|
||||
|
||||
export interface IQueryOptions {
|
||||
text?: string;
|
||||
ids?: string[];
|
||||
names?: string[];
|
||||
pageSize?: number;
|
||||
sortBy?: SortBy;
|
||||
sortOrder?: SortOrder;
|
||||
source?: string;
|
||||
}
|
||||
|
||||
export const enum StatisticType {
|
||||
Uninstall = 'uninstall'
|
||||
}
|
||||
|
||||
export interface IReportedExtension {
|
||||
id: IExtensionIdentifier;
|
||||
malicious: boolean;
|
||||
}
|
||||
|
||||
export const enum InstallOperation {
|
||||
None = 0,
|
||||
Install,
|
||||
Update
|
||||
}
|
||||
|
||||
export interface ITranslation {
|
||||
contents: { [key: string]: {} };
|
||||
}
|
||||
|
||||
export const IExtensionGalleryService = createDecorator<IExtensionGalleryService>('extensionGalleryService');
|
||||
export interface IExtensionGalleryService {
|
||||
readonly _serviceBrand: undefined;
|
||||
isEnabled(): boolean;
|
||||
query(token: CancellationToken): Promise<IPager<IGalleryExtension>>;
|
||||
query(options: IQueryOptions, token: CancellationToken): Promise<IPager<IGalleryExtension>>;
|
||||
getExtensions(ids: string[], token: CancellationToken): Promise<IGalleryExtension[]>;
|
||||
download(extension: IGalleryExtension, location: URI, operation: InstallOperation): Promise<void>;
|
||||
reportStatistic(publisher: string, name: string, version: string, type: StatisticType): Promise<void>;
|
||||
getReadme(extension: IGalleryExtension, token: CancellationToken): Promise<string>;
|
||||
getManifest(extension: IGalleryExtension, token: CancellationToken): Promise<IExtensionManifest | null>;
|
||||
getChangelog(extension: IGalleryExtension, token: CancellationToken): Promise<string>;
|
||||
getCoreTranslation(extension: IGalleryExtension, languageId: string): Promise<ITranslation | null>;
|
||||
getAllVersions(extension: IGalleryExtension, compatible: boolean): Promise<IGalleryExtensionVersion[]>;
|
||||
getExtensionsReport(): Promise<IReportedExtension[]>;
|
||||
getCompatibleExtension(extension: IGalleryExtension): Promise<IGalleryExtension | null>;
|
||||
getCompatibleExtension(id: IExtensionIdentifier, version?: string): Promise<IGalleryExtension | null>;
|
||||
}
|
||||
|
||||
export interface InstallExtensionEvent {
|
||||
identifier: IExtensionIdentifier;
|
||||
zipPath?: string;
|
||||
gallery?: IGalleryExtension;
|
||||
}
|
||||
|
||||
export interface DidInstallExtensionEvent {
|
||||
identifier: IExtensionIdentifier;
|
||||
operation: InstallOperation;
|
||||
zipPath?: string;
|
||||
gallery?: IGalleryExtension;
|
||||
local?: ILocalExtension;
|
||||
error?: string;
|
||||
}
|
||||
|
||||
export interface DidUninstallExtensionEvent {
|
||||
identifier: IExtensionIdentifier;
|
||||
error?: string;
|
||||
}
|
||||
|
||||
export const INSTALL_ERROR_NOT_SUPPORTED = 'notsupported';
|
||||
export const INSTALL_ERROR_MALICIOUS = 'malicious';
|
||||
export const INSTALL_ERROR_INCOMPATIBLE = 'incompatible';
|
||||
|
||||
export class ExtensionManagementError extends Error {
|
||||
constructor(message: string, readonly code: string) {
|
||||
super(message);
|
||||
}
|
||||
}
|
||||
|
||||
export type InstallOptions = { isBuiltin?: boolean, isMachineScoped?: boolean };
|
||||
|
||||
export const IExtensionManagementService = createDecorator<IExtensionManagementService>('extensionManagementService');
|
||||
export interface IExtensionManagementService {
|
||||
readonly _serviceBrand: undefined;
|
||||
|
||||
onInstallExtension: Event<InstallExtensionEvent>;
|
||||
onDidInstallExtension: Event<DidInstallExtensionEvent>;
|
||||
onUninstallExtension: Event<IExtensionIdentifier>;
|
||||
onDidUninstallExtension: Event<DidUninstallExtensionEvent>;
|
||||
|
||||
zip(extension: ILocalExtension): Promise<URI>;
|
||||
unzip(zipLocation: URI): Promise<IExtensionIdentifier>;
|
||||
getManifest(vsix: URI): Promise<IExtensionManifest>;
|
||||
install(vsix: URI, options?: InstallOptions): Promise<ILocalExtension>;
|
||||
canInstall(extension: IGalleryExtension): Promise<boolean>;
|
||||
installFromGallery(extension: IGalleryExtension, options?: InstallOptions): Promise<ILocalExtension>;
|
||||
uninstall(extension: ILocalExtension, force?: boolean): Promise<void>;
|
||||
reinstallFromGallery(extension: ILocalExtension): Promise<void>;
|
||||
getInstalled(type?: ExtensionType): Promise<ILocalExtension[]>;
|
||||
getExtensionsReport(): Promise<IReportedExtension[]>;
|
||||
|
||||
updateMetadata(local: ILocalExtension, metadata: IGalleryMetadata): Promise<ILocalExtension>;
|
||||
updateExtensionScope(local: ILocalExtension, isMachineScoped: boolean): Promise<ILocalExtension>;
|
||||
}
|
||||
|
||||
export const DISABLED_EXTENSIONS_STORAGE_PATH = 'extensionsIdentifiers/disabled';
|
||||
export const ENABLED_EXTENSIONS_STORAGE_PATH = 'extensionsIdentifiers/enabled';
|
||||
export const IGlobalExtensionEnablementService = createDecorator<IGlobalExtensionEnablementService>('IGlobalExtensionEnablementService');
|
||||
|
||||
export interface IGlobalExtensionEnablementService {
|
||||
readonly _serviceBrand: undefined;
|
||||
readonly onDidChangeEnablement: Event<{ readonly extensions: IExtensionIdentifier[], readonly source?: string }>;
|
||||
|
||||
getDisabledExtensions(): IExtensionIdentifier[];
|
||||
enableExtension(extension: IExtensionIdentifier, source?: string): Promise<boolean>;
|
||||
disableExtension(extension: IExtensionIdentifier, source?: string): Promise<boolean>;
|
||||
|
||||
}
|
||||
|
||||
export type IConfigBasedExtensionTip = {
|
||||
readonly extensionId: string,
|
||||
readonly extensionName: string,
|
||||
readonly isExtensionPack: boolean,
|
||||
readonly configName: string,
|
||||
readonly important: boolean,
|
||||
};
|
||||
|
||||
export type IExecutableBasedExtensionTip = {
|
||||
readonly extensionId: string,
|
||||
readonly extensionName: string,
|
||||
readonly isExtensionPack: boolean,
|
||||
readonly exeName: string,
|
||||
readonly exeFriendlyName: string,
|
||||
readonly windowsPath?: string,
|
||||
};
|
||||
|
||||
export type IWorkspaceTips = { readonly remoteSet: string[]; readonly recommendations: string[]; };
|
||||
|
||||
export const IExtensionTipsService = createDecorator<IExtensionTipsService>('IExtensionTipsService');
|
||||
export interface IExtensionTipsService {
|
||||
readonly _serviceBrand: undefined;
|
||||
|
||||
getConfigBasedTips(folder: URI): Promise<IConfigBasedExtensionTip[]>;
|
||||
getImportantExecutableBasedTips(): Promise<IExecutableBasedExtensionTip[]>;
|
||||
getOtherExecutableBasedTips(): Promise<IExecutableBasedExtensionTip[]>;
|
||||
getAllWorkspacesTips(): Promise<IWorkspaceTips[]>;
|
||||
}
|
||||
|
||||
|
||||
export const DefaultIconPath = FileAccess.asBrowserUri('./media/defaultIcon.png', require).toString(true);
|
||||
export const ExtensionsLabel = localize('extensions', "Extensions");
|
||||
export const ExtensionsLocalizedLabel = { value: ExtensionsLabel, original: 'Extensions' };
|
||||
export const ExtensionsChannelId = 'extensions';
|
||||
export const PreferencesLabel = localize('preferences', "Preferences");
|
||||
export const PreferencesLocalizedLabel = { value: PreferencesLabel, original: 'Preferences' };
|
||||
@@ -0,0 +1,164 @@
|
||||
/*---------------------------------------------------------------------------------------------
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
* Licensed under the MIT License. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
|
||||
import { IChannel, IServerChannel } from 'vs/base/parts/ipc/common/ipc';
|
||||
import { IExtensionManagementService, ILocalExtension, InstallExtensionEvent, DidInstallExtensionEvent, IGalleryExtension, DidUninstallExtensionEvent, IExtensionIdentifier, IGalleryMetadata, IReportedExtension, IExtensionTipsService, InstallOptions } from 'vs/platform/extensionManagement/common/extensionManagement';
|
||||
import { Event } from 'vs/base/common/event';
|
||||
import { URI, UriComponents } from 'vs/base/common/uri';
|
||||
import { IURITransformer, DefaultURITransformer, transformAndReviveIncomingURIs } from 'vs/base/common/uriIpc';
|
||||
import { cloneAndChange } from 'vs/base/common/objects';
|
||||
import { ExtensionType, IExtensionManifest } from 'vs/platform/extensions/common/extensions';
|
||||
|
||||
function transformIncomingURI(uri: UriComponents, transformer: IURITransformer | null): URI {
|
||||
return URI.revive(transformer ? transformer.transformIncoming(uri) : uri);
|
||||
}
|
||||
|
||||
function transformOutgoingURI(uri: URI, transformer: IURITransformer | null): URI {
|
||||
return transformer ? transformer.transformOutgoingURI(uri) : uri;
|
||||
}
|
||||
|
||||
function transformIncomingExtension(extension: ILocalExtension, transformer: IURITransformer | null): ILocalExtension {
|
||||
transformer = transformer ? transformer : DefaultURITransformer;
|
||||
const manifest = extension.manifest;
|
||||
const transformed = transformAndReviveIncomingURIs({ ...extension, ...{ manifest: undefined } }, transformer);
|
||||
return { ...transformed, ...{ manifest } };
|
||||
}
|
||||
|
||||
function transformOutgoingExtension(extension: ILocalExtension, transformer: IURITransformer | null): ILocalExtension {
|
||||
return transformer ? cloneAndChange(extension, value => value instanceof URI ? transformer.transformOutgoingURI(value) : undefined) : extension;
|
||||
}
|
||||
|
||||
export class ExtensionManagementChannel implements IServerChannel {
|
||||
|
||||
onInstallExtension: Event<InstallExtensionEvent>;
|
||||
onDidInstallExtension: Event<DidInstallExtensionEvent>;
|
||||
onUninstallExtension: Event<IExtensionIdentifier>;
|
||||
onDidUninstallExtension: Event<DidUninstallExtensionEvent>;
|
||||
|
||||
constructor(private service: IExtensionManagementService, private getUriTransformer: (requestContext: any) => IURITransformer | null) {
|
||||
this.onInstallExtension = Event.buffer(service.onInstallExtension, true);
|
||||
this.onDidInstallExtension = Event.buffer(service.onDidInstallExtension, true);
|
||||
this.onUninstallExtension = Event.buffer(service.onUninstallExtension, true);
|
||||
this.onDidUninstallExtension = Event.buffer(service.onDidUninstallExtension, true);
|
||||
}
|
||||
|
||||
listen(context: any, event: string): Event<any> {
|
||||
const uriTransformer = this.getUriTransformer(context);
|
||||
switch (event) {
|
||||
case 'onInstallExtension': return this.onInstallExtension;
|
||||
case 'onDidInstallExtension': return Event.map(this.onDidInstallExtension, i => ({ ...i, local: i.local ? transformOutgoingExtension(i.local, uriTransformer) : i.local }));
|
||||
case 'onUninstallExtension': return this.onUninstallExtension;
|
||||
case 'onDidUninstallExtension': return this.onDidUninstallExtension;
|
||||
}
|
||||
|
||||
throw new Error('Invalid listen');
|
||||
}
|
||||
|
||||
call(context: any, command: string, args?: any): Promise<any> {
|
||||
const uriTransformer: IURITransformer | null = this.getUriTransformer(context);
|
||||
switch (command) {
|
||||
case 'zip': return this.service.zip(transformIncomingExtension(args[0], uriTransformer)).then(uri => transformOutgoingURI(uri, uriTransformer));
|
||||
case 'unzip': return this.service.unzip(transformIncomingURI(args[0], uriTransformer));
|
||||
case 'install': return this.service.install(transformIncomingURI(args[0], uriTransformer));
|
||||
case 'getManifest': return this.service.getManifest(transformIncomingURI(args[0], uriTransformer));
|
||||
case 'canInstall': return this.service.canInstall(args[0]);
|
||||
case 'installFromGallery': return this.service.installFromGallery(args[0], args[1]);
|
||||
case 'uninstall': return this.service.uninstall(transformIncomingExtension(args[0], uriTransformer), args[1]);
|
||||
case 'reinstallFromGallery': return this.service.reinstallFromGallery(transformIncomingExtension(args[0], uriTransformer));
|
||||
case 'getInstalled': return this.service.getInstalled(args[0]).then(extensions => extensions.map(e => transformOutgoingExtension(e, uriTransformer)));
|
||||
case 'updateMetadata': return this.service.updateMetadata(transformIncomingExtension(args[0], uriTransformer), args[1]).then(e => transformOutgoingExtension(e, uriTransformer));
|
||||
case 'updateExtensionScope': return this.service.updateExtensionScope(transformIncomingExtension(args[0], uriTransformer), args[1]).then(e => transformOutgoingExtension(e, uriTransformer));
|
||||
case 'getExtensionsReport': return this.service.getExtensionsReport();
|
||||
}
|
||||
|
||||
throw new Error('Invalid call');
|
||||
}
|
||||
}
|
||||
|
||||
export class ExtensionManagementChannelClient implements IExtensionManagementService {
|
||||
|
||||
declare readonly _serviceBrand: undefined;
|
||||
|
||||
constructor(
|
||||
private readonly channel: IChannel,
|
||||
) { }
|
||||
|
||||
get onInstallExtension(): Event<InstallExtensionEvent> { return this.channel.listen('onInstallExtension'); }
|
||||
get onDidInstallExtension(): Event<DidInstallExtensionEvent> { return Event.map(this.channel.listen<DidInstallExtensionEvent>('onDidInstallExtension'), i => ({ ...i, local: i.local ? transformIncomingExtension(i.local, null) : i.local })); }
|
||||
get onUninstallExtension(): Event<IExtensionIdentifier> { return this.channel.listen('onUninstallExtension'); }
|
||||
get onDidUninstallExtension(): Event<DidUninstallExtensionEvent> { return this.channel.listen('onDidUninstallExtension'); }
|
||||
|
||||
zip(extension: ILocalExtension): Promise<URI> {
|
||||
return Promise.resolve(this.channel.call('zip', [extension]).then(result => URI.revive(<UriComponents>result)));
|
||||
}
|
||||
|
||||
unzip(zipLocation: URI): Promise<IExtensionIdentifier> {
|
||||
return Promise.resolve(this.channel.call('unzip', [zipLocation]));
|
||||
}
|
||||
|
||||
install(vsix: URI): Promise<ILocalExtension> {
|
||||
return Promise.resolve(this.channel.call<ILocalExtension>('install', [vsix])).then(local => transformIncomingExtension(local, null));
|
||||
}
|
||||
|
||||
getManifest(vsix: URI): Promise<IExtensionManifest> {
|
||||
return Promise.resolve(this.channel.call<IExtensionManifest>('getManifest', [vsix]));
|
||||
}
|
||||
|
||||
async canInstall(extension: IGalleryExtension): Promise<boolean> {
|
||||
return true;
|
||||
}
|
||||
|
||||
installFromGallery(extension: IGalleryExtension, installOptions?: InstallOptions): Promise<ILocalExtension> {
|
||||
return Promise.resolve(this.channel.call<ILocalExtension>('installFromGallery', [extension, installOptions])).then(local => transformIncomingExtension(local, null));
|
||||
}
|
||||
|
||||
uninstall(extension: ILocalExtension, force = false): Promise<void> {
|
||||
return Promise.resolve(this.channel.call('uninstall', [extension!, force]));
|
||||
}
|
||||
|
||||
reinstallFromGallery(extension: ILocalExtension): Promise<void> {
|
||||
return Promise.resolve(this.channel.call('reinstallFromGallery', [extension]));
|
||||
}
|
||||
|
||||
getInstalled(type: ExtensionType | null = null): Promise<ILocalExtension[]> {
|
||||
return Promise.resolve(this.channel.call<ILocalExtension[]>('getInstalled', [type]))
|
||||
.then(extensions => extensions.map(extension => transformIncomingExtension(extension, null)));
|
||||
}
|
||||
|
||||
updateMetadata(local: ILocalExtension, metadata: IGalleryMetadata): Promise<ILocalExtension> {
|
||||
return Promise.resolve(this.channel.call<ILocalExtension>('updateMetadata', [local, metadata]))
|
||||
.then(extension => transformIncomingExtension(extension, null));
|
||||
}
|
||||
|
||||
updateExtensionScope(local: ILocalExtension, isMachineScoped: boolean): Promise<ILocalExtension> {
|
||||
return Promise.resolve(this.channel.call<ILocalExtension>('updateExtensionScope', [local, isMachineScoped]))
|
||||
.then(extension => transformIncomingExtension(extension, null));
|
||||
}
|
||||
|
||||
getExtensionsReport(): Promise<IReportedExtension[]> {
|
||||
return Promise.resolve(this.channel.call('getExtensionsReport'));
|
||||
}
|
||||
}
|
||||
|
||||
export class ExtensionTipsChannel implements IServerChannel {
|
||||
|
||||
constructor(private service: IExtensionTipsService) {
|
||||
}
|
||||
|
||||
listen(context: any, event: string): Event<any> {
|
||||
throw new Error('Invalid listen');
|
||||
}
|
||||
|
||||
call(context: any, command: string, args?: any): Promise<any> {
|
||||
switch (command) {
|
||||
case 'getConfigBasedTips': return this.service.getConfigBasedTips(URI.revive(args[0]));
|
||||
case 'getImportantExecutableBasedTips': return this.service.getImportantExecutableBasedTips();
|
||||
case 'getOtherExecutableBasedTips': return this.service.getOtherExecutableBasedTips();
|
||||
case 'getAllWorkspacesTips': return this.service.getAllWorkspacesTips();
|
||||
}
|
||||
|
||||
throw new Error('Invalid call');
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,126 @@
|
||||
/*---------------------------------------------------------------------------------------------
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
* Licensed under the MIT License. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
|
||||
import { ILocalExtension, IGalleryExtension, IExtensionIdentifier, IReportedExtension, IExtensionIdentifierWithVersion } from 'vs/platform/extensionManagement/common/extensionManagement';
|
||||
import { compareIgnoreCase } from 'vs/base/common/strings';
|
||||
import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
|
||||
|
||||
export function areSameExtensions(a: IExtensionIdentifier, b: IExtensionIdentifier): boolean {
|
||||
if (a.uuid && b.uuid) {
|
||||
return a.uuid === b.uuid;
|
||||
}
|
||||
if (a.id === b.id) {
|
||||
return true;
|
||||
}
|
||||
return compareIgnoreCase(a.id, b.id) === 0;
|
||||
}
|
||||
|
||||
export class ExtensionIdentifierWithVersion implements IExtensionIdentifierWithVersion {
|
||||
|
||||
readonly id: string;
|
||||
readonly uuid?: string;
|
||||
|
||||
constructor(
|
||||
identifier: IExtensionIdentifier,
|
||||
readonly version: string
|
||||
) {
|
||||
this.id = identifier.id;
|
||||
this.uuid = identifier.uuid;
|
||||
}
|
||||
|
||||
key(): string {
|
||||
return `${this.id}-${this.version}`;
|
||||
}
|
||||
|
||||
equals(o: any): boolean {
|
||||
if (!(o instanceof ExtensionIdentifierWithVersion)) {
|
||||
return false;
|
||||
}
|
||||
return areSameExtensions(this, o) && this.version === o.version;
|
||||
}
|
||||
}
|
||||
|
||||
export function adoptToGalleryExtensionId(id: string): string {
|
||||
return id.toLocaleLowerCase();
|
||||
}
|
||||
|
||||
export function getGalleryExtensionId(publisher: string, name: string): string {
|
||||
return `${publisher.toLocaleLowerCase()}.${name.toLocaleLowerCase()}`;
|
||||
}
|
||||
|
||||
export function groupByExtension<T>(extensions: T[], getExtensionIdentifier: (t: T) => IExtensionIdentifier): T[][] {
|
||||
const byExtension: T[][] = [];
|
||||
const findGroup = (extension: T) => {
|
||||
for (const group of byExtension) {
|
||||
if (group.some(e => areSameExtensions(getExtensionIdentifier(e), getExtensionIdentifier(extension)))) {
|
||||
return group;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
};
|
||||
for (const extension of extensions) {
|
||||
const group = findGroup(extension);
|
||||
if (group) {
|
||||
group.push(extension);
|
||||
} else {
|
||||
byExtension.push([extension]);
|
||||
}
|
||||
}
|
||||
return byExtension;
|
||||
}
|
||||
|
||||
export function getLocalExtensionTelemetryData(extension: ILocalExtension): any {
|
||||
return {
|
||||
id: extension.identifier.id,
|
||||
name: extension.manifest.name,
|
||||
galleryId: null,
|
||||
publisherId: extension.publisherId,
|
||||
publisherName: extension.manifest.publisher,
|
||||
publisherDisplayName: extension.publisherDisplayName,
|
||||
dependencies: extension.manifest.extensionDependencies && extension.manifest.extensionDependencies.length > 0
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
/* __GDPR__FRAGMENT__
|
||||
"GalleryExtensionTelemetryData" : {
|
||||
"id" : { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
|
||||
"name": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
|
||||
"galleryId": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
|
||||
"publisherId": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
|
||||
"publisherName": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
|
||||
"publisherDisplayName": { "classification": "SystemMetaData", "purpose": "FeatureInsight" },
|
||||
"dependencies": { "classification": "SystemMetaData", "purpose": "FeatureInsight", "isMeasurement": true },
|
||||
"${include}": [
|
||||
"${GalleryExtensionTelemetryData2}"
|
||||
]
|
||||
}
|
||||
*/
|
||||
export function getGalleryExtensionTelemetryData(extension: IGalleryExtension): any {
|
||||
return {
|
||||
id: extension.identifier.id,
|
||||
name: extension.name,
|
||||
galleryId: extension.identifier.uuid,
|
||||
publisherId: extension.publisherId,
|
||||
publisherName: extension.publisher,
|
||||
publisherDisplayName: extension.publisherDisplayName,
|
||||
dependencies: !!(extension.properties.dependencies && extension.properties.dependencies.length > 0),
|
||||
...extension.telemetryData
|
||||
};
|
||||
}
|
||||
|
||||
export const BetterMergeId = new ExtensionIdentifier('pprice.better-merge');
|
||||
|
||||
export function getMaliciousExtensionsSet(report: IReportedExtension[]): Set<string> {
|
||||
const result = new Set<string>();
|
||||
|
||||
for (const extension of report) {
|
||||
if (extension.malicious) {
|
||||
result.add(extension.id.id);
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
/*---------------------------------------------------------------------------------------------
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
* Licensed under the MIT License. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
|
||||
import { cloneAndChange } from 'vs/base/common/objects';
|
||||
import { IExtensionManifest } from 'vs/platform/extensions/common/extensions';
|
||||
|
||||
const nlsRegex = /^%([\w\d.-]+)%$/i;
|
||||
|
||||
export interface ITranslations {
|
||||
[key: string]: string;
|
||||
}
|
||||
|
||||
export function localizeManifest(manifest: IExtensionManifest, translations: ITranslations): IExtensionManifest {
|
||||
const patcher = (value: string) => {
|
||||
if (typeof value !== 'string') {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
const match = nlsRegex.exec(value);
|
||||
|
||||
if (!match) {
|
||||
return undefined;
|
||||
}
|
||||
|
||||
return translations[match[1]] || value;
|
||||
};
|
||||
|
||||
return cloneAndChange(manifest, patcher);
|
||||
}
|
||||
@@ -0,0 +1,113 @@
|
||||
/*---------------------------------------------------------------------------------------------
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
* Licensed under the MIT License. See License.txt in the project root for license information.
|
||||
*--------------------------------------------------------------------------------------------*/
|
||||
|
||||
import { URI } from 'vs/base/common/uri';
|
||||
import { IProductService, IConfigBasedExtensionTip as IRawConfigBasedExtensionTip } from 'vs/platform/product/common/productService';
|
||||
import { IFileService } from 'vs/platform/files/common/files';
|
||||
import { isNonEmptyArray } from 'vs/base/common/arrays';
|
||||
import { IExtensionTipsService, IExecutableBasedExtensionTip, IWorkspaceTips, IConfigBasedExtensionTip } from 'vs/platform/extensionManagement/common/extensionManagement';
|
||||
import { forEach } from 'vs/base/common/collections';
|
||||
import { IRequestService, asJson } from 'vs/platform/request/common/request';
|
||||
import { CancellationToken } from 'vs/base/common/cancellation';
|
||||
import { ILogService } from 'vs/platform/log/common/log';
|
||||
import { joinPath } from 'vs/base/common/resources';
|
||||
import { getDomainsOfRemotes } from 'vs/platform/extensionManagement/common/configRemotes';
|
||||
import { Disposable } from 'vs/base/common/lifecycle';
|
||||
|
||||
export class ExtensionTipsService extends Disposable implements IExtensionTipsService {
|
||||
|
||||
_serviceBrand: any;
|
||||
|
||||
private readonly allConfigBasedTips: Map<string, IRawConfigBasedExtensionTip> = new Map<string, IRawConfigBasedExtensionTip>();
|
||||
|
||||
constructor(
|
||||
@IFileService protected readonly fileService: IFileService,
|
||||
@IProductService private readonly productService: IProductService,
|
||||
@IRequestService private readonly requestService: IRequestService,
|
||||
@ILogService private readonly logService: ILogService,
|
||||
) {
|
||||
super();
|
||||
if (this.productService.configBasedExtensionTips) {
|
||||
forEach(this.productService.configBasedExtensionTips, ({ value }) => this.allConfigBasedTips.set(value.configPath, value));
|
||||
}
|
||||
}
|
||||
|
||||
getConfigBasedTips(folder: URI): Promise<IConfigBasedExtensionTip[]> {
|
||||
return this.getValidConfigBasedTips(folder);
|
||||
}
|
||||
|
||||
getAllWorkspacesTips(): Promise<IWorkspaceTips[]> {
|
||||
return this.fetchWorkspacesTips();
|
||||
}
|
||||
|
||||
async getImportantExecutableBasedTips(): Promise<IExecutableBasedExtensionTip[]> {
|
||||
return [];
|
||||
}
|
||||
|
||||
async getOtherExecutableBasedTips(): Promise<IExecutableBasedExtensionTip[]> {
|
||||
return [];
|
||||
}
|
||||
|
||||
private async getValidConfigBasedTips(folder: URI): Promise<IConfigBasedExtensionTip[]> {
|
||||
const result: IConfigBasedExtensionTip[] = [];
|
||||
for (const [configPath, tip] of this.allConfigBasedTips) {
|
||||
try {
|
||||
const content = await this.fileService.readFile(joinPath(folder, configPath));
|
||||
const recommendationByRemote: Map<string, IConfigBasedExtensionTip> = new Map<string, IConfigBasedExtensionTip>();
|
||||
forEach(tip.recommendations, ({ key, value }) => {
|
||||
if (isNonEmptyArray(value.remotes)) {
|
||||
for (const remote of value.remotes) {
|
||||
recommendationByRemote.set(remote, {
|
||||
extensionId: key,
|
||||
extensionName: value.name,
|
||||
configName: tip.configName,
|
||||
important: !!value.important,
|
||||
isExtensionPack: !!value.isExtensionPack
|
||||
});
|
||||
}
|
||||
} else {
|
||||
result.push({
|
||||
extensionId: key,
|
||||
extensionName: value.name,
|
||||
configName: tip.configName,
|
||||
important: !!value.important,
|
||||
isExtensionPack: !!value.isExtensionPack
|
||||
});
|
||||
}
|
||||
});
|
||||
const domains = getDomainsOfRemotes(content.value.toString(), [...recommendationByRemote.keys()]);
|
||||
for (const domain of domains) {
|
||||
const remote = recommendationByRemote.get(domain);
|
||||
if (remote) {
|
||||
result.push(remote);
|
||||
}
|
||||
}
|
||||
} catch (error) { /* Ignore */ }
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
private async fetchWorkspacesTips(): Promise<IWorkspaceTips[]> {
|
||||
if (!this.productService.extensionsGallery?.recommendationsUrl) {
|
||||
return [];
|
||||
}
|
||||
try {
|
||||
const context = await this.requestService.request({ type: 'GET', url: this.productService.extensionsGallery?.recommendationsUrl }, CancellationToken.None);
|
||||
if (context.res.statusCode !== 200) {
|
||||
return [];
|
||||
}
|
||||
const result = await asJson<{ workspaceRecommendations?: IWorkspaceTips[] }>(context);
|
||||
if (!result) {
|
||||
return [];
|
||||
}
|
||||
return result.workspaceRecommendations || [];
|
||||
} catch (error) {
|
||||
this.logService.error(error);
|
||||
return [];
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 1.0 KiB |
Reference in New Issue
Block a user