[gitlab] Allow adding Git Provider using a relative URL

Signed-off-by: Alex Tugarev <[email protected]>

Author: AlexTugarev

components/server/src/auth/auth-provider-service.ts

@@ -144,7 +144,7 @@ export class AuthProviderService {
     protected callbackUrl = (host: string) => {
         const pathname = `/auth/${host}/callback`;
         if (this.env.devBranch) {
-            // for example: https://staging.gitpod-dev.com/auth/gitlab.com/callback
+            // for example: https://staging.gitpod-dev.com/auth/mydomain.com/gitlab/callback
             return this.env.hostUrl.withoutDomainPrefix(1).with({ pathname }).toString();
         }
         return this.env.hostUrl.with({ pathname }).toString();

components/server/src/gitlab/gitlab-context-parser.ts

@@ -245,6 +245,9 @@ export class GitlabContextParser extends AbstractContextParser implements IConte
         };
     }
     protected async fetchRepo(user: User, projectId: number | string): Promise<Repository> {
+        // host might be a relative URL
+        const host = this.host; // as per contract, cf. `canHandle(user, contextURL)`
+
         const result = await this.gitlabApi.run<GitLab.Project>(user, async g => {
             return g.Projects.show(projectId);
         });
@@ -253,18 +256,24 @@ export class GitlabContextParser extends AbstractContextParser implements IConte
         }
         const { path, http_url_to_repo, namespace, forked_from_project, default_branch, visibility } = result;
         const repo = <Repository>{
-            host: new URL(http_url_to_repo).hostname,
+            host,
             name: path, // path is the last part of the URI (slug), e.g. "diaspora-project-site"
             owner: namespace.full_path,
             cloneUrl: http_url_to_repo,
             defaultBranch: default_branch,
             private: visibility === 'private'
         }
         if (forked_from_project) {
+
+            // host might be a relative URL, let's compute the prefix
+            const url = new URL(forked_from_project.http_url_to_repo.split(forked_from_project.namespace.full_path)[0]);
+            const relativePath = url.pathname.slice(1); // hint: pathname always starts with `/`
+            const host = relativePath ? `${url.hostname}/${relativePath}` : url.hostname;
+
             repo.fork = {
                 parent: {
                     name: forked_from_project.path,
-                    host: new URL(forked_from_project.http_url_to_repo).hostname,
+                    host,
                     owner: forked_from_project.namespace.full_path,
                     cloneUrl: forked_from_project.http_url_to_repo,
                     defaultBranch: forked_from_project.default_branch

components/server/src/workspace/context-parser.ts

@@ -22,12 +22,16 @@ export abstract class AbstractContextParser implements IContextParser {
 
     @inject(AuthProviderParams) protected config: AuthProviderParams;
 
+    protected get host(): string {
+        return this.config.host;
+    }
+
     public normalize(contextUrl: string): string | undefined {
         let url = contextUrl.trim();
-        if (url.startsWith(`${this.config.host}/`)) {
+        if (url.startsWith(`${this.host}/`)) {
             url = `https://${url}`;
         }
-        if (url.startsWith(`https://${this.config.host}/`)) {
+        if (url.startsWith(`https://${this.host}/`)) {
             return url;
         }
         return undefined;
@@ -41,14 +45,24 @@ export abstract class AbstractContextParser implements IContextParser {
         const url = new URL(contextUrl);
         const pathname = url.pathname.replace(/^\//, "").replace(/\/$/, ""); // pathname without leading and trailing slash
         const segments = pathname.split('/');
+
+        const host = this.host; // as per contract, cf. `canHandle(user, contextURL)`
+
+        const lenghtOfRelativePath = host.split("/").length - 1; // e.g. "123.123.123.123/gitlab" => length of 1
+        if (lenghtOfRelativePath > 0) {
+            // remove segments from the path to be consider further, which belong to the relative location of the host
+            // cf. https://github.com/gitpod-io/gitpod/issues/2637
+            segments.splice(0, lenghtOfRelativePath);
+        }
+
         var owner: string = segments[0];
         var repoName: string = segments[1];
         var moreSegmentsStart: number = 2;
         const endsWithRepoName = segments.length === moreSegmentsStart;
         const searchParams = url.searchParams;
         return {
-            host: url.hostname,
-            owner: owner,
+            host,
+            owner,
             repoName: this.parseRepoName(repoName, endsWithRepoName),
             moreSegments: endsWithRepoName ? [] : segments.slice(moreSegmentsStart),
             searchParams

components/server/src/workspace/gitpod-server-impl.ts

@@ -1520,7 +1520,11 @@ export class GitpodServerImpl<Client extends GitpodClient, Server extends Gitpod
     }
 
     // from https://stackoverflow.com/questions/106179/regular-expression-to-match-dns-hostname-or-ip-address/106223#106223
-    protected validHostNameRegexp = /^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])$/;
+    // adapted to allow for hostnames
+    //   from [foo.bar] pumped up to [foo.(foo.)bar]
+    // and also for a trailing path segments
+    //   for example [foo.bar/gitlab]
+    protected validHostNameRegexp = /^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)+([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])(\/([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9]))?$/;
 
     async updateOwnAuthProvider({ entry }: GitpodServer.UpdateOwnAuthProviderParams): Promise<void> {
         let userId: string;

components/theia/packages/gitpod-extension/src/browser/git-host-watcher.ts

@@ -32,15 +32,32 @@ export class GitHostWatcher implements FrontendApplicationContribution {
         this.gitRepository.onDidChangeRepository(() => this.update());
     }
 
-    protected gitHost: string | undefined;
+    protected remoteUrl: string | undefined;
     protected async update() {
         const selectedRepo = this.gitRepository.selectedRepository;
-        const gitHost = selectedRepo && await this.getGitHost(selectedRepo);
-        if (this.gitHost === gitHost) {
-            return;
+        let remoteUrl = selectedRepo && await this.getRemoteUrl(selectedRepo);
+
+        // updates should be performed on changes only
+        {
+            if (this.remoteUrl === remoteUrl?.toString()) {
+                return;
+            }
+            this.remoteUrl = remoteUrl?.toString();
         }
-        this.gitHost = gitHost;
-        const authProvider = gitHost && await this.getAuthProviderByHost(gitHost);
+
+        let gitHost = remoteUrl && remoteUrl.hostname;
+        let authProvider = gitHost && await this.getAuthProviderByHost(gitHost);
+        if (!authProvider && gitHost && remoteUrl) {
+            // in case we cannot find the provider by hostname, let's try with simple path
+
+            const pathSegments = remoteUrl.pathname.split("/");
+            const gitHostWithPath = `${remoteUrl.pathname}/${pathSegments[0] || pathSegments[1]}`;
+            authProvider = await this.getAuthProviderByHost(gitHostWithPath);
+            if (authProvider) {
+                gitHost = gitHostWithPath;
+            }
+        }
+
         const type = authProvider && authProvider.authProviderType;
         this.updateExtensions(type, gitHost);
     }
@@ -64,19 +81,11 @@ export class GitHostWatcher implements FrontendApplicationContribution {
         return this.authProviders;
     }
 
-    protected async getGitHost(repository: Repository): Promise<string | undefined> {
-        const remoteUrl = await this.getRemoteUrl(repository);
-        if (!remoteUrl) {
-            return undefined;
-        }
-        const gitHost = new URL(remoteUrl).hostname;
-        return gitHost;
-    }
-
-    async getRemoteUrl(repository: Repository): Promise<string | undefined> {
+    async getRemoteUrl(repository: Repository): Promise<URL | undefined> {
         try {
             const remoteUrlResult = await this.git.exec(repository, ["remote", "get-url", "origin"]);
-            return remoteUrlResult.stdout.trim();
+            const result = remoteUrlResult.stdout.trim();
+            return new URL(result);
         } catch (e) {
             return undefined;
         }

components/theia/packages/gitpod-extension/src/browser/gitpod-git-token-provider.ts

@@ -61,7 +61,13 @@ export class GitpodGitTokenProvider {
     async getGitToken(params: GetGitTokenParams): Promise<GetGitTokenResult> {
         const validationParams: TokenValidationParams = { ...params };
 
-        const token = await this.getTokenFromServer(params.host);
+        let token = await this.getTokenFromServer(params.host);
+        if (!token && params.repoURL) {
+            const url = new URL(params.repoURL);
+            const pathSegments = url.pathname.split("/");
+            const hostAndPath = `${url.host}/${pathSegments[0] || pathSegments[1]}`;
+            token = await this.getTokenFromServer(hostAndPath);
+        }
         if (token) {
             const tokenUser = token.username || "oauth2";
             // if required scopes are missing, we can validate async