clean up and add some tracing

Author: selfcontained

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

@@ -5,7 +5,7 @@
  */
 
 import { injectable, inject } from "inversify";
-import { AuthProviderEntry as AuthProviderEntry, User } from "@gitpod/gitpod-protocol";
+import { AuthProviderEntry as AuthProviderEntry, AuthProviderInfo, User } from "@gitpod/gitpod-protocol";
 import { AuthProviderParams } from "./auth-provider";
 import { AuthProviderEntryDB, TeamDB } from "@gitpod/gitpod-db/lib";
 import { Config } from "../config";
@@ -16,6 +16,7 @@ import { oauthUrls as bbsUrls } from "../bitbucket-server/bitbucket-server-urls"
 import { oauthUrls as bbUrls } from "../bitbucket/bitbucket-urls";
 import { log } from "@gitpod/gitpod-protocol/lib/util/logging";
 import fetch from "node-fetch";
+import { HostContextProvider } from "./host-context-provider";
 
 @injectable()
 export class AuthProviderService {
@@ -28,6 +29,60 @@ export class AuthProviderService {
     @inject(Config)
     protected readonly config: Config;
 
+    @inject(HostContextProvider)
+    private readonly hostContextProvider: HostContextProvider;
+
+    public async getAuthProvidersInfo(user?: User): Promise<AuthProviderInfo[]> {
+        const { builtinAuthProvidersConfigured } = this.config;
+
+        const hostContexts = this.hostContextProvider.getAll();
+        const authProviders = hostContexts.map((hc) => hc.authProvider.info);
+
+        const isBuiltIn = (info: AuthProviderInfo) => !info.ownerId;
+        const isNotHidden = (info: AuthProviderInfo) => !info.hiddenOnDashboard;
+        const isVerified = (info: AuthProviderInfo) => info.verified;
+        const isNotOrgProvider = (info: AuthProviderInfo) => !info.organizationId;
+
+        // if no user session is available, compute public information only
+        if (!user) {
+            const toPublic = (info: AuthProviderInfo) =>
+                <AuthProviderInfo>{
+                    authProviderId: info.authProviderId,
+                    authProviderType: info.authProviderType,
+                    disallowLogin: info.disallowLogin,
+                    host: info.host,
+                    icon: info.icon,
+                    description: info.description,
+                };
+            let result = authProviders.filter(isNotHidden).filter(isVerified).filter(isNotOrgProvider);
+            if (builtinAuthProvidersConfigured) {
+                result = result.filter(isBuiltIn);
+            }
+            return result.map(toPublic);
+        }
+
+        // otherwise show all the details
+        const result: AuthProviderInfo[] = [];
+        for (const info of authProviders) {
+            const identity = user.identities.find((i) => i.authProviderId === info.authProviderId);
+            if (identity) {
+                result.push({ ...info, isReadonly: identity.readonly });
+                continue;
+            }
+            if (info.ownerId === user.id) {
+                result.push(info);
+                continue;
+            }
+            if (builtinAuthProvidersConfigured && !isBuiltIn(info)) {
+                continue;
+            }
+            if (isNotHidden(info) && isVerified(info)) {
+                result.push(info);
+            }
+        }
+        return result;
+    }
+
     /**
      * Returns all auth providers.
      */

components/server/src/projects/scm-service.ts

@@ -4,18 +4,30 @@
  * See License.AGPL.txt in the project root for license information.
  */
 
-import { Project, User } from "@gitpod/gitpod-protocol";
+import { CommitContext, Project, SuggestedRepository, User, WorkspaceInfo } from "@gitpod/gitpod-protocol";
 import { RepoURL } from "../repohost";
 import { inject, injectable } from "inversify";
 import { HostContextProvider } from "../auth/host-context-provider";
 import { Config } from "../config";
-import { log } from "@gitpod/gitpod-protocol/lib/util/logging";
+import { LogContext, log } from "@gitpod/gitpod-protocol/lib/util/logging";
+import { ProjectsService } from "./projects-service";
+import { WorkspaceService } from "../workspace/workspace-service";
+import { AuthProviderService } from "../auth/auth-provider-service";
+import { TraceContext } from "@gitpod/gitpod-protocol/lib/util/tracing";
+
+type SuggestedRepositoryWithSorting = SuggestedRepository & {
+    priority: number;
+    lastUse?: string;
+};
 
 @injectable()
 export class ScmService {
     constructor(
         @inject(HostContextProvider) private readonly hostContextProvider: HostContextProvider,
         @inject(Config) private readonly config: Config,
+        @inject(ProjectsService) private readonly projectsService: ProjectsService,
+        @inject(WorkspaceService) private readonly workspaceService: WorkspaceService,
+        @inject(AuthProviderService) private readonly authProviderService: AuthProviderService,
     ) {}
 
     async canInstallWebhook(currentUser: User, cloneURL: string) {
@@ -74,4 +86,156 @@ export class ScmService {
             }
         }
     }
+
+    public async getSuggestedRepositories(ctx: TraceContext, user: User, organizationId: string) {
+        const logCtx: LogContext = { userId: user.id };
+        const span = TraceContext.startSpan("SCMService.getSuggestedRepositories", ctx);
+
+        const repoResults = await Promise.allSettled([
+            this.fetchProjects(ctx, user, organizationId).catch((e) =>
+                log.error(logCtx, "Could not fetch projects", e),
+            ),
+            this.fetchUserRepos(ctx, user).catch((e) => log.error(logCtx, "Could not fetch user repositories", e)),
+            this.fetchRecentRepos(ctx, user, organizationId).catch((e) =>
+                log.error(logCtx, "Could not fetch recent repositories", e),
+            ),
+        ]);
+
+        const sortedRepos = repoResults
+            // filter out rejected promises
+            .map((r) => (r.status === "fulfilled" ? r.value || [] : []))
+            // flatten out results from all promises
+            .flat()
+            .sort((a, b) => {
+                // priority first
+                if (a.priority !== b.priority) {
+                    return a.priority < b.priority ? 1 : -1;
+                }
+                // Most recently used second
+                if (b.lastUse || a.lastUse) {
+                    const la = a.lastUse || "";
+                    const lb = b.lastUse || "";
+                    return la < lb ? 1 : la === lb ? 0 : -1;
+                }
+                // Otherwise, alphasort
+                const ua = a.url.toLowerCase();
+                const ub = b.url.toLowerCase();
+                return ua > ub ? 1 : ua === ub ? 0 : -1;
+            });
+
+        const uniqueRepositories = new Map<string, SuggestedRepositoryWithSorting>();
+
+        for (const repo of sortedRepos) {
+            const existingRepo = uniqueRepositories.get(repo.url);
+
+            uniqueRepositories.set(repo.url, {
+                ...(existingRepo || {}),
+                ...repo,
+            });
+        }
+
+        // Convert to return type
+        const result = Array.from(uniqueRepositories.values()).map(
+            (repo): SuggestedRepository => ({
+                url: repo.url,
+                projectId: repo.projectId,
+                projectName: repo.projectName,
+            }),
+        );
+
+        span.finish();
+
+        return result;
+    }
+
+    private async fetchProjects(
+        ctx: TraceContext,
+        user: User,
+        organizationId: string,
+    ): Promise<SuggestedRepositoryWithSorting[]> {
+        const span = TraceContext.startSpan("SCMService.fetchProjects", ctx);
+        const projects = await this.projectsService.getProjects(user.id, organizationId);
+        span.finish();
+
+        return projects.map((project) => ({
+            url: project.cloneUrl.replace(/\.git$/, ""),
+            projectId: project.id,
+            projectName: project.name,
+            priority: 1,
+        }));
+    }
+
+    // Load user repositories (from Git hosts directly)
+    private async fetchUserRepos(ctx: TraceContext, user: User): Promise<SuggestedRepositoryWithSorting[]> {
+        const span = TraceContext.startSpan("SCMService.fetchUserRepos", ctx);
+        const logCtx: LogContext = { userId: user.id };
+
+        const authProviders = await this.authProviderService.getAuthProvidersInfo(user);
+
+        const providerRepos = await Promise.all(
+            authProviders.map(async (p): Promise<SuggestedRepositoryWithSorting[]> => {
+                try {
+                    span.setTag("host", p.host);
+
+                    const hostContext = this.hostContextProvider.get(p.host);
+                    const services = hostContext?.services;
+                    if (!services) {
+                        log.error(logCtx, "Unsupported repository host: " + p.host);
+                        return [];
+                    }
+                    const userRepos = await services.repositoryProvider.getUserRepos(user);
+
+                    return userRepos.map((r) => ({
+                        url: r.replace(/\.git$/, ""),
+                        priority: 5,
+                    }));
+                } catch (error) {
+                    log.debug(logCtx, "Could not get user repositories from host " + p.host, error);
+                }
+
+                return [];
+            }),
+        );
+
+        span.finish();
+
+        return providerRepos.flat();
+    }
+
+    private async fetchRecentRepos(
+        ctx: TraceContext,
+        user: User,
+        organizationId: string,
+    ): Promise<SuggestedRepositoryWithSorting[]> {
+        const span = TraceContext.startSpan("SCMService.fetchRecentRepos", ctx);
+
+        // TODO: do we need to check permissions on each ws here like we do in gitpod server?
+        const workspaces = await this.workspaceService.getWorkspaces(user.id, { organizationId });
+
+        const recentRepos: SuggestedRepositoryWithSorting[] = [];
+
+        for (const ws of workspaces) {
+            let repoUrl;
+            if (CommitContext.is(ws.workspace.context)) {
+                repoUrl = ws.workspace.context?.repository?.cloneUrl?.replace(/\.git$/, "");
+            }
+            if (!repoUrl) {
+                repoUrl = ws.workspace.contextURL;
+            }
+            if (repoUrl) {
+                const lastUse = WorkspaceInfo.lastActiveISODate(ws);
+
+                recentRepos.push({
+                    url: repoUrl,
+                    projectId: ws.workspace.projectId,
+                    priority: 10,
+                    lastUse,
+                });
+            }
+        }
+
+        span.finish();
+
+        return recentRepos;
+    }
 }