When turned to using service account for a Sandbox a wrong warning me…

src/openshift/cluster.ts

@@ -28,7 +28,9 @@
 
 export interface QuickPickItemExt extends QuickPickItem {
     name: string,
-    cluster: string
+    cluster: string,
+    user: string,
+    namespace: string
 }
 
 export class Cluster extends OpenShiftItem {
@@ -186,6 +188,8 @@
             .map((ctx) => ({
                 name: `${ctx.name}`,
                 cluster: `${ctx.cluster}`,
+                user: `${ctx.user}`,
+                namespace: `${ctx.namespace}`,
                 label: `${ctx.label}`,
                 description: `on ${ctx.cluster}`,
                 detail: `User: ${ctx.user}`,
@@ -223,8 +227,9 @@
                             if (await LoginUtil.Instance.requireLogin(clusterURL)) {
                                 const status = await Cluster.login(choice.name, true);
                                 if (status) {
+                                    const newKcu = new KubeConfigUtils(); // Can be updated after login
                                     if (Cluster.isSandboxCluster(clusterURL)
-                                            && !k8sConfig.equalsToCurrentContext(choice.name)) {
+                                            && !newKcu.equalsToCurrentContext(choice.name, choice.cluster, choice.namespace, choice.user)) {
                                         await window.showWarningMessage(
                                             'The cluster appears to be a OpenShift Dev Sandbox cluster, \
                                             but the required project doesn\'t appear to be existing. \
@@ -840,19 +845,19 @@
         } else {
             ocToken = userToken;
         }
         return Progress.execFunctionWithProgress(`Login to the cluster: ${clusterURL}`, async () => {
             try {
                 await Oc.Instance.loginWithToken(clusterURL, ocToken);
                 if (Cluster.isOpenShiftSandbox(clusterURL)) {
                     const YES = 'Yes';
                     const result = await window.showInformationMessage('OpenShift Sandbox logs you out after 15 minutes. Would you like to switch to a service account to prevent this?', YES, 'No');
                     if (result === YES) {
                         await Cluster.installPipelineUserContext();
                     }
                 }
                 return Cluster.loginMessage(clusterURL);
             } catch (error) {
                 throw new VsCommandError(
                     `Failed to login to cluster '${clusterURL}' with '${Filters.filterToken(
                         error.message,
                     )}'!`,
@@ -886,14 +891,14 @@
         return Cluster.tokenLogin(apiEndpointUrl, true, clipboard);
     }
 
     static async installPipelineUserContext(): Promise<void> {
         const kcu = new KubeConfigUtils();
         const kcFiles = getKubeConfigFiles();
         if (kcFiles.length === 0) {
             throw new Error('Could not locate Kube Config when trying to replace OpenShift Sandbox token with a longer-lived token');
         }
         const kcPath = kcFiles[0];
         const kcActual = YAML.load((await fs.readFile(kcPath)).toString('utf-8')) as {
             users: { name: string; user: { token: string } }[];
             contexts: {
                 context: { cluster: string; user: string; namespace: string };
@@ -903,20 +908,20 @@
             clusters: object[];
         };
 
         const currentCtx = kcu.getCurrentContext();
         const currentCtxObj = kcActual.contexts.find(ctx => ctx.name === currentCtx);
         const sandboxUser = currentCtxObj.context.user;
         const sandboxUserObj = kcActual.users.find(user => user.name === sandboxUser);
 
         const secrets = await Oc.Instance.getKubernetesObjects('Secret');
         const pipelineTokenSecret = secrets.find((secret) => secret.metadata.name.startsWith('pipeline-token')) as any;
         const pipelineToken = Buffer.from(pipelineTokenSecret.data.token, 'base64').toString();
 
         sandboxUserObj.user = {
             token: pipelineToken
         }
 
         await fs.writeFile(kcPath, YAML.dump(kcActual, { lineWidth: Number.POSITIVE_INFINITY }));
     }
 
     static async loginUsingClipboardInfo(dashboardUrl: string): Promise<string | null> {
@@ -941,8 +946,8 @@
         return `Successfully logged in to '${clusterURL}'`;
     }
 
     static isOpenShiftSandbox(url :string): boolean {
         const asUrl = new URL(url);
         return asUrl.hostname.endsWith('openshiftapps.com');
     }
 }

src/util/kubeUtils.ts

@@ -128,24 +128,15 @@
         return undefined;
     }
 
-    public equalContexts(c1:string, c2:string): boolean {
-        if (c1 === c2) return true;
-        const context1 = this.findContext(c1);
-        const context2 = this.findContext(c2);
-        if (context1 === context2) return true; // Both are undefibed or reference the same object
-        if (context1 === undefined && context2 !== undefined) return false;
-        if (context1 === undefined && context2 !== undefined) return false;
-        if (context1.cluster !== context2.cluster) return false;
-        if (context1.namespace !== context2.namespace) return false;
-        if (context1.user !== context2.user) return false;
-        return true;
-    }
-
-    public equalsToCurrentContext(contextName:string): boolean {
+    public equalsToCurrentContext(contextName:string, cluster: string, namespace: string, user: string): boolean {
         const currentContext = this.findContext(this.currentContext);
         if (!currentContext) return false;
 
-        return this.equalContexts(currentContext.name, contextName);
+        if (currentContext.name !== contextName) return false;
+        if (currentContext.cluster !== cluster) return false;
+        if (currentContext.namespace !== namespace) return false;
+        if (currentContext.user !== user) return false;
+        return true;
     }
 }