Browse Source
Adds live share support
Keeps all path manipulation on the host rather than guest Fixes shared/local path munging for mac/windows Keeps current user lookup local when a guest Keeps difftool lookup local when a guest Avoids fetch date lookup when a guest Stops clearing node_modules (for now)main
Eric Amodio
6 years ago
18 changed files with 709 additions and 70 deletions
Split View
Diff Options
-
+12 -11README.md
-
+5 -0package-lock.json
-
+9 -2package.json
-
+1 -0src/codelens/codeLensProvider.ts
-
+2 -1src/constants.ts
-
+8 -0src/container.ts
-
+23 -7src/git/git.ts
-
+80 -44src/git/gitService.ts
-
+10 -1src/git/gitUri.ts
-
+1 -1src/git/models/repository.ts
-
+1 -1src/git/shell.ts
-
+2 -1src/trackers/documentTracker.ts
-
+3 -0src/ui/config.ts
-
+106 -0src/vsls/guest.ts
-
+276 -0src/vsls/host.ts
-
+54 -0src/vsls/protocol.ts
-
+112 -0src/vsls/vsls.ts
-
+4 -1webpack.config.js
+ 12
- 11
README.md
View File
+ 5
- 0
package-lock.json
View File
+ 9
- 2
package.json
View File
+ 1
- 0
src/codelens/codeLensProvider.ts
View File
+ 2
- 1
src/constants.ts
View File
+ 8
- 0
src/container.ts
View File
+ 23
- 7
src/git/git.ts
View File
+ 80
- 44
src/git/gitService.ts
View File
+ 10
- 1
src/git/gitUri.ts
View File
+ 1
- 1
src/git/models/repository.ts
View File
+ 1
- 1
src/git/shell.ts
View File
+ 2
- 1
src/trackers/documentTracker.ts
View File
+ 3
- 0
src/ui/config.ts
View File
+ 106
- 0
src/vsls/guest.ts
View File
| @ -0,0 +1,106 @@ | |||
| 'use strict'; | |||
| import { CancellationToken, Disposable, window, WorkspaceFolder } from 'vscode'; | |||
| import { LiveShare, SharedServiceProxy } from 'vsls'; | |||
| import { CommandContext, setCommandContext } from '../constants'; | |||
| import { GitCommandOptions, Repository, RepositoryChange } from '../git/git'; | |||
| import { Logger } from '../logger'; | |||
| import { debug, log } from '../system'; | |||
| import { VslsHostService } from './host'; | |||
| import { | |||
| GitCommandRequestType, | |||
| RepositoriesInFolderRequestType, | |||
| RepositoryProxy, | |||
| RequestType, | |||
| WorkspaceFileExistsRequestType | |||
| } from './protocol'; | |||
| export class VslsGuestService implements Disposable { | |||
| @log() | |||
| static async connect(api: LiveShare) { | |||
| const cc = Logger.getCorrelationContext(); | |||
| try { | |||
| const service = await api.getSharedService(VslsHostService.ServiceId); | |||
| if (service == null) { | |||
| throw new Error('Failed to connect to host service'); | |||
| } | |||
| return new VslsGuestService(api, service); | |||
| } | |||
| catch (ex) { | |||
| Logger.error(ex, cc); | |||
| return undefined; | |||
| } | |||
| } | |||
| constructor( | |||
| private readonly _api: LiveShare, | |||
| private readonly _service: SharedServiceProxy | |||
| ) { | |||
| _service.onDidChangeIsServiceAvailable(this.onAvailabilityChanged.bind(this)); | |||
| this.onAvailabilityChanged(_service.isServiceAvailable); | |||
| } | |||
| dispose() {} | |||
| @log() | |||
| private async onAvailabilityChanged(available: boolean) { | |||
| if (available) { | |||
| setCommandContext(CommandContext.Enabled, true); | |||
| return; | |||
| } | |||
| setCommandContext(CommandContext.Enabled, false); | |||
| void window.showWarningMessage( | |||
| `GitLens features will be unavailable. Unable to connect to the host GitLens service. The host may have disabled GitLens guest access or may not have GitLens installed.` | |||
| ); | |||
| } | |||
| @log() | |||
| async git<TOut extends string | Buffer>(options: GitCommandOptions, ...args: any[]) { | |||
| const response = await this.sendRequest(GitCommandRequestType, { options: options, args: args }); | |||
| if (response.isBuffer) { | |||
| return new Buffer(response.data, 'binary') as TOut; | |||
| } | |||
| return response.data as TOut; | |||
| } | |||
| @log() | |||
| async getRepositoriesInFolder( | |||
| folder: WorkspaceFolder, | |||
| onAnyRepositoryChanged: (repo: Repository, reason: RepositoryChange) => void | |||
| ): Promise<Repository[]> { | |||
| const response = await this.sendRequest(RepositoriesInFolderRequestType, { | |||
| folderUri: folder.uri.toString(true) | |||
| }); | |||
| return response.repositories.map( | |||
| (r: RepositoryProxy) => new Repository(folder, r.path, r.root, onAnyRepositoryChanged, false, r.closed) | |||
| ); | |||
| } | |||
| @log() | |||
| async fileExists( | |||
| repoPath: string, | |||
| fileName: string, | |||
| options: { ensureCase: boolean } = { ensureCase: false } | |||
| ): Promise<boolean> { | |||
| const response = await this.sendRequest(WorkspaceFileExistsRequestType, { | |||
| fileName: fileName, | |||
| repoPath: repoPath, | |||
| options: options | |||
| }); | |||
| return response.exists; | |||
| } | |||
| @debug() | |||
| private sendRequest<TRequest, TResponse>( | |||
| requestType: RequestType<TRequest, TResponse>, | |||
| request: TRequest, | |||
| cancellation?: CancellationToken | |||
| ): Promise<TResponse> { | |||
| return this._service.request(requestType.name, [request]); | |||
| } | |||
| } | |||
+ 276
- 0
src/vsls/host.ts
View File
| @ -0,0 +1,276 @@ | |||
| 'use strict'; | |||
| import { CancellationToken, Disposable, Uri, workspace, WorkspaceFoldersChangeEvent } from 'vscode'; | |||
| import { LiveShare, SharedService } from 'vsls'; | |||
| import { Container } from '../container'; | |||
| import { git } from '../git/git'; | |||
| import { GitUri } from '../git/gitUri'; | |||
| import { Logger } from '../logger'; | |||
| import { debug, Iterables, log, Strings } from '../system'; | |||
| import { | |||
| GitCommandRequest, | |||
| GitCommandRequestType, | |||
| GitCommandResponse, | |||
| RepositoriesInFolderRequest, | |||
| RepositoriesInFolderRequestType, | |||
| RepositoriesInFolderResponse, | |||
| RequestType, | |||
| WorkspaceFileExistsRequest, | |||
| WorkspaceFileExistsRequestType, | |||
| WorkspaceFileExistsResponse | |||
| } from './protocol'; | |||
| import { vslsUriRootRegex } from './vsls'; | |||
| const leadingSlashRegex = /^[\/|\\]/; | |||
| export class VslsHostService implements Disposable { | |||
| static ServiceId = 'proxy'; | |||
| @log() | |||
| static async share(api: LiveShare) { | |||
| const service = await api.shareService(this.ServiceId); | |||
| if (service == null) { | |||
| throw new Error('Failed to share host service'); | |||
| } | |||
| return new VslsHostService(api, service); | |||
| } | |||
| private readonly _disposable: Disposable; | |||
| private _localPathsRegex: RegExp | undefined; | |||
| private _localToSharedPaths = new Map<string, string>(); | |||
| private _sharedPathsRegex: RegExp | undefined; | |||
| private _sharedToLocalPaths = new Map<string, string>(); | |||
| constructor( | |||
| private readonly _api: LiveShare, | |||
| private readonly _service: SharedService | |||
| ) { | |||
| _service.onDidChangeIsServiceAvailable(this.onAvailabilityChanged.bind(this)); | |||
| this._disposable = Disposable.from(workspace.onDidChangeWorkspaceFolders(this.onWorkspaceFoldersChanged, this)); | |||
| this.onRequest(GitCommandRequestType, this.onGitCommandRequest.bind(this)); | |||
| this.onRequest(RepositoriesInFolderRequestType, this.onRepositoriesInFolderRequest.bind(this)); | |||
| this.onRequest(WorkspaceFileExistsRequestType, this.onWorkspaceFileExistsRequest.bind(this)); | |||
| this.onWorkspaceFoldersChanged(); | |||
| } | |||
| dispose() { | |||
| this._disposable.dispose(); | |||
| void this._api.unshareService(VslsHostService.ServiceId); | |||
| } | |||
| private onRequest<TRequest, TResponse>( | |||
| requestType: RequestType<TRequest, TResponse>, | |||
| handler: (request: TRequest, cancellation: CancellationToken) => Promise<TResponse> | |||
| ) { | |||
| this._service.onRequest(requestType.name, (args: any[], cancellation: CancellationToken) => | |||
| handler(args[0], cancellation) | |||
| ); | |||
| } | |||
| @log() | |||
| private onAvailabilityChanged(available: boolean) { | |||
| // TODO | |||
| } | |||
| @debug() | |||
| private async onWorkspaceFoldersChanged(e?: WorkspaceFoldersChangeEvent) { | |||
| if (workspace.workspaceFolders === undefined || workspace.workspaceFolders.length === 0) return; | |||
| const cc = Logger.getCorrelationContext(); | |||
| this._localToSharedPaths.clear(); | |||
| this._sharedToLocalPaths.clear(); | |||
| let localPath; | |||
| let sharedPath; | |||
| for (const f of workspace.workspaceFolders) { | |||
| localPath = Strings.normalizePath(f.uri.fsPath); | |||
| sharedPath = Strings.normalizePath(this.convertLocalUriToShared(f.uri).fsPath); | |||
| Logger.debug(cc, `shared='${sharedPath}' \u2194 local='${localPath}'`); | |||
| this._localToSharedPaths.set(localPath, sharedPath); | |||
| this._sharedToLocalPaths.set(sharedPath, localPath); | |||
| } | |||
| let localPaths = Iterables.join(this._sharedToLocalPaths.values(), '|'); | |||
| localPaths = localPaths.replace(/(\/|\\)/g, '[\\\\/|\\\\]'); | |||
| this._localPathsRegex = new RegExp(`(${localPaths})`, 'gi'); | |||
| let sharedPaths = Iterables.join(this._localToSharedPaths.values(), '|'); | |||
| sharedPaths = sharedPaths.replace(/(\/|\\)/g, '[\\\\/|\\\\]'); | |||
| this._sharedPathsRegex = new RegExp(`^(${sharedPaths})`, 'i'); | |||
| } | |||
| @log() | |||
| private async onGitCommandRequest( | |||
| request: GitCommandRequest, | |||
| cancellation: CancellationToken | |||
| ): Promise<GitCommandResponse> { | |||
| const { options, args } = request; | |||
| let isRootWorkspace = false; | |||
| if (options.cwd !== undefined && options.cwd.length > 0 && this._sharedToLocalPaths !== undefined) { | |||
| // This is all so ugly, but basically we are converting shared paths to local paths | |||
| if (this._sharedPathsRegex !== undefined && this._sharedPathsRegex.test(options.cwd)) { | |||
| options.cwd = Strings.normalizePath(options.cwd).replace(this._sharedPathsRegex, (match, shared) => { | |||
| if (!isRootWorkspace) { | |||
| isRootWorkspace = shared === '/~0'; | |||
| } | |||
| const local = this._sharedToLocalPaths.get(shared); | |||
| return local != null ? local : shared; | |||
| }); | |||
| } | |||
| else if (leadingSlashRegex.test(options.cwd)) { | |||
| const localCwd = this._sharedToLocalPaths.get('/~0'); | |||
| if (localCwd !== undefined) { | |||
| isRootWorkspace = true; | |||
| options.cwd = GitUri.resolve(options.cwd, localCwd); | |||
| } | |||
| } | |||
| } | |||
| let files = false; | |||
| let i = -1; | |||
| for (const arg of args) { | |||
| i++; | |||
| if (arg === '--') { | |||
| files = true; | |||
| continue; | |||
| } | |||
| if (!files) continue; | |||
| if (typeof arg === 'string') { | |||
| // If we are the "root" workspace, then we need to remove the leading slash off the path (otherwise it will not be treated as a relative path) | |||
| if (isRootWorkspace && leadingSlashRegex.test(arg[0])) { | |||
| args.splice(i, 1, arg.substr(1)); | |||
| } | |||
| if (this._sharedPathsRegex !== undefined && this._sharedPathsRegex.test(arg)) { | |||
| args.splice( | |||
| i, | |||
| 1, | |||
| Strings.normalizePath(arg).replace(this._sharedPathsRegex, (match, shared) => { | |||
| const local = this._sharedToLocalPaths.get(shared); | |||
| return local != null ? local : shared; | |||
| }) | |||
| ); | |||
| } | |||
| } | |||
| } | |||
| let data = await git(options, ...args); | |||
| if (typeof data === 'string') { | |||
| // And then we convert local paths to shared paths | |||
| if (this._localPathsRegex !== undefined && data.length > 0) { | |||
| data = data.replace(this._localPathsRegex, (match, local) => { | |||
| const shared = this._localToSharedPaths.get(local); | |||
| return shared != null ? shared : local; | |||
| }); | |||
| } | |||
| return { data: data }; | |||
| } | |||
| return { data: data.toString('binary'), isBuffer: true }; | |||
| } | |||
| @log() | |||
| private async onRepositoriesInFolderRequest( | |||
| request: RepositoriesInFolderRequest, | |||
| cancellation: CancellationToken | |||
| ): Promise<RepositoriesInFolderResponse> { | |||
| const uri = this.convertSharedUriToLocal(Uri.parse(request.folderUri)); | |||
| const normalized = Strings.normalizePath(uri.fsPath, { stripTrailingSlash: true }).toLowerCase(); | |||
| const repos = [ | |||
| ...Iterables.filterMap(await Container.git.getRepositories(), r => { | |||
| if (!r.normalizedPath.startsWith(normalized)) return undefined; | |||
| const vslsUri = this.convertLocalUriToShared(r.folder.uri); | |||
| return { | |||
| folderUri: vslsUri.toString(true), | |||
| path: vslsUri.path, | |||
| root: r.root, | |||
| closed: r.closed | |||
| }; | |||
| }) | |||
| ]; | |||
| return { | |||
| repositories: repos | |||
| }; | |||
| } | |||
| @log() | |||
| private async onWorkspaceFileExistsRequest( | |||
| request: WorkspaceFileExistsRequest, | |||
| cancellation: CancellationToken | |||
| ): Promise<WorkspaceFileExistsResponse> { | |||
| let { repoPath } = request; | |||
| if (this._sharedPathsRegex !== undefined && this._sharedPathsRegex.test(repoPath)) { | |||
| repoPath = Strings.normalizePath(repoPath).replace(this._sharedPathsRegex, (match, shared) => { | |||
| const local = this._sharedToLocalPaths!.get(shared); | |||
| return local != null ? local : shared; | |||
| }); | |||
| } | |||
| // TODO: Lock this to be only in the contained workspaces | |||
| return { exists: await Container.git.fileExists(repoPath, request.fileName, request.options) }; | |||
| } | |||
| @debug({ | |||
| exit: result => `returned ${result.toString(true)}` | |||
| }) | |||
| private convertLocalUriToShared(localUri: Uri) { | |||
| const cc = Logger.getCorrelationContext(); | |||
| let sharedUri = this._api.convertLocalUriToShared(localUri); | |||
| Logger.debug( | |||
| cc, | |||
| `LiveShare.convertLocalUriToShared(${localUri.toString(true)}) returned ${sharedUri.toString(true)}` | |||
| ); | |||
| const localPath = localUri.path; | |||
| let sharedPath = sharedUri.path; | |||
| if (sharedUri.authority.length > 0) { | |||
| sharedPath = `/${sharedUri.authority}${sharedPath}`; | |||
| } | |||
| if (new RegExp(`${localPath}$`, 'i').test(sharedPath)) { | |||
| if (sharedPath.length === localPath.length) { | |||
| const folder = workspace.getWorkspaceFolder(localUri)!; | |||
| sharedUri = sharedUri.with({ path: `/~${folder.index}` }); | |||
| } | |||
| else { | |||
| sharedUri = sharedUri.with({ path: sharedPath.substr(0, sharedPath.length - localPath.length) }); | |||
| } | |||
| } | |||
| else if (!sharedPath.startsWith('/~')) { | |||
| const folder = workspace.getWorkspaceFolder(localUri)!; | |||
| sharedUri = sharedUri.with({ path: `/~${folder.index}${sharedPath}` }); | |||
| } | |||
| return sharedUri; | |||
| } | |||
| private convertSharedUriToLocal(sharedUri: Uri) { | |||
| if (vslsUriRootRegex.test(sharedUri.path)) { | |||
| sharedUri = sharedUri.with({ path: `${sharedUri.path}/` }); | |||
| } | |||
| const localUri = this._api.convertSharedUriToLocal(sharedUri); | |||
| const localPath = localUri.path; | |||
| const sharedPath = sharedUri.path; | |||
| if (localPath.endsWith(sharedPath)) { | |||
| return localUri.with({ path: localPath.substr(0, localPath.length - sharedPath.length) }); | |||
| } | |||
| return localUri; | |||
| } | |||
| } | |||
+ 54
- 0
src/vsls/protocol.ts
View File
| @ -0,0 +1,54 @@ | |||
| 'use strict'; | |||
| import { GitCommandOptions } from '../git/git'; | |||
| export class RequestType<TRequest, TResponse> { | |||
| constructor( | |||
| public readonly name: string | |||
| ) {} | |||
| } | |||
| export interface GitCommandRequest { | |||
| options: GitCommandOptions; | |||
| args: any[]; | |||
| } | |||
| export interface GitCommandResponse { | |||
| data: string; | |||
| isBuffer?: boolean; | |||
| } | |||
| export const GitCommandRequestType = new RequestType<GitCommandRequest, GitCommandResponse>('git'); | |||
| export interface RepositoryProxy { | |||
| folderUri: string; | |||
| path: string; | |||
| root: boolean; | |||
| closed: boolean; | |||
| } | |||
| export interface RepositoriesInFolderRequest { | |||
| folderUri: string; | |||
| } | |||
| export interface RepositoriesInFolderResponse { | |||
| repositories: RepositoryProxy[]; | |||
| } | |||
| export const RepositoriesInFolderRequestType = new RequestType< | |||
| RepositoriesInFolderRequest, | |||
| RepositoriesInFolderResponse | |||
| >('repositories/inFolder'); | |||
| export interface WorkspaceFileExistsRequest { | |||
| fileName: string; | |||
| repoPath: string; | |||
| options: { ensureCase: boolean }; | |||
| } | |||
| export interface WorkspaceFileExistsResponse { | |||
| exists: boolean; | |||
| } | |||
| export const WorkspaceFileExistsRequestType = new RequestType<WorkspaceFileExistsRequest, WorkspaceFileExistsResponse>( | |||
| 'workspace/fileExists' | |||
| ); | |||
+ 112
- 0
src/vsls/vsls.ts
View File
| @ -0,0 +1,112 @@ | |||
| 'use strict'; | |||
| import { Disposable, workspace } from 'vscode'; | |||
| import { getApi, LiveShare, Role, SessionChangeEvent } from 'vsls'; | |||
| import { CommandContext, DocumentSchemes, setCommandContext } from '../constants'; | |||
| import { Container } from '../container'; | |||
| import { Logger } from './../logger'; | |||
| import { VslsGuestService } from './guest'; | |||
| import { VslsHostService } from './host'; | |||
| export const vslsUriPrefixRegex = /^[\/|\\]~\d+?(?:[\/|\\]|$)/; | |||
| export const vslsUriRootRegex = /^[\/|\\]~\d+?$/; | |||
| export class VslsController implements Disposable { | |||
| private _disposable: Disposable | undefined; | |||
| private _guest: VslsGuestService | undefined; | |||
| private _host: VslsHostService | undefined; | |||
| private _onReady: (() => void) | undefined; | |||
| private _waitForReady: Promise<void> | undefined; | |||
| constructor() { | |||
| void this.initialize(); | |||
| } | |||
| dispose() { | |||
| this._disposable && this._disposable.dispose(); | |||
| if (this._host !== undefined) { | |||
| this._host.dispose(); | |||
| } | |||
| if (this._guest !== undefined) { | |||
| this._guest.dispose(); | |||
| } | |||
| } | |||
| private async initialize() { | |||
| try { | |||
| // If we have a vsls: workspace open, we might be a guest, so wait until live share transitions into a mode | |||
| if ( | |||
| workspace.workspaceFolders !== undefined && | |||
| workspace.workspaceFolders.some(f => f.uri.scheme === DocumentSchemes.Vsls) | |||
| ) { | |||
| this._waitForReady = new Promise(resolve => (this._onReady = resolve)); | |||
| } | |||
| const api = await getApi(); | |||
| if (api == null) { | |||
| // Tear it down if we can't talk to live share | |||
| if (this._onReady !== undefined) { | |||
| this._onReady(); | |||
| this._waitForReady = undefined; | |||
| } | |||
| return; | |||
| } | |||
| this._disposable = Disposable.from( | |||
| api.onDidChangeSession(e => this.onLiveShareSessionChanged(api, e), this) | |||
| ); | |||
| } | |||
| catch (ex) { | |||
| debugger; | |||
| Logger.error(ex); | |||
| return; | |||
| } | |||
| } | |||
| get isMaybeGuest() { | |||
| return this._guest !== undefined || this._waitForReady !== undefined; | |||
| } | |||
| async guest() { | |||
| if (this._waitForReady !== undefined) { | |||
| await this._waitForReady; | |||
| this._waitForReady = undefined; | |||
| } | |||
| return this._guest; | |||
| } | |||
| host() { | |||
| return this._host; | |||
| } | |||
| private async onLiveShareSessionChanged(api: LiveShare, e: SessionChangeEvent) { | |||
| if (this._host !== undefined) { | |||
| this._host.dispose(); | |||
| } | |||
| if (this._guest !== undefined) { | |||
| this._guest.dispose(); | |||
| } | |||
| switch (e.session.role) { | |||
| case Role.Host: | |||
| if (Container.config.liveshare.allowGuestAccess) { | |||
| this._host = await VslsHostService.share(api); | |||
| } | |||
| break; | |||
| case Role.Guest: | |||
| this._guest = await VslsGuestService.connect(api); | |||
| break; | |||
| default: | |||
| break; | |||
| } | |||
| if (this._onReady !== undefined) { | |||
| this._onReady(); | |||
| this._onReady = undefined; | |||
| } | |||
| } | |||
| } | |||