make naming more consistent

Author: Hweinstock

packages/core/src/awsService/ec2/model.ts

@@ -44,7 +44,7 @@ export class Ec2ConnectionManager {
     protected ssmClient: SsmClient
     protected ec2Client: Ec2Client
     protected iamClient: DefaultIamClient
-    protected envManager: Ec2RemoteSessionManager
+    protected sessionManager: Ec2RemoteSessionManager
 
     private policyDocumentationUri = vscode.Uri.parse(
         'https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-getting-started-instance-profile.html'
@@ -58,7 +58,7 @@ export class Ec2ConnectionManager {
         this.ssmClient = this.createSsmSdkClient()
         this.ec2Client = this.createEc2SdkClient()
         this.iamClient = this.createIamSdkClient()
-        this.envManager = new Ec2RemoteSessionManager(regionCode, this.ssmClient)
+        this.sessionManager = new Ec2RemoteSessionManager(regionCode, this.ssmClient)
     }
 
     protected createSsmSdkClient(): SsmClient {
@@ -73,16 +73,16 @@ export class Ec2ConnectionManager {
         return new DefaultIamClient(this.regionCode)
     }
 
-    public async addActiveEnv(sessionId: SSM.SessionId, instanceId: EC2.InstanceId): Promise<void> {
-        await this.envManager.addEnv(instanceId, sessionId)
+    public async addActiveSession(sessionId: SSM.SessionId, instanceId: EC2.InstanceId): Promise<void> {
+        await this.sessionManager.addSession(instanceId, sessionId)
     }
 
     public async closeConnections(): Promise<void> {
-        await this.envManager.closeConnections()
+        await this.sessionManager.closeConnections()
     }
 
     public isConnectedTo(instanceId: string): boolean {
-        return this.envManager.isConnectedTo(instanceId)
+        return this.sessionManager.isConnectedTo(instanceId)
     }
 
     public async getAttachedIamRole(instanceId: string): Promise<IAM.Role | undefined> {
@@ -225,7 +225,7 @@ export class Ec2ConnectionManager {
             throw err
         }
         const ssmSession = await this.ssmClient.startSession(selection.instanceId, 'AWS-StartSSHSession')
-        await this.envManager.addEnv(selection.instanceId, ssmSession.SessionId!)
+        await this.addActiveSession(selection.instanceId, ssmSession.SessionId!)
 
         const vars = getEc2SsmEnv(selection, ssm, ssmSession)
         const envProvider = async () => {

packages/core/src/awsService/ec2/remoteSessionManager.ts

@@ -7,35 +7,35 @@ import { EC2, SSM } from 'aws-sdk'
 import { SsmClient } from '../../shared/clients/ssmClient'
 
 export class Ec2RemoteSessionManager {
-    private activeEnvs: Map<EC2.InstanceId, SSM.SessionId>
+    private activeSessions: Map<EC2.InstanceId, SSM.SessionId>
 
     public constructor(
         readonly regionCode: string,
         protected ssmClient: SsmClient
     ) {
-        this.activeEnvs = new Map<EC2.InstanceId, SSM.SessionId>()
+        this.activeSessions = new Map<EC2.InstanceId, SSM.SessionId>()
     }
 
-    public async addEnv(instanceId: EC2.InstanceId, sessionId: SSM.SessionId): Promise<void> {
+    public async addSession(instanceId: EC2.InstanceId, sessionId: SSM.SessionId): Promise<void> {
         if (this.isConnectedTo(instanceId)) {
-            const existingSessionId = this.activeEnvs.get(instanceId)!
+            const existingSessionId = this.activeSessions.get(instanceId)!
             await this.ssmClient.terminateSessionFromId(existingSessionId)
-            this.activeEnvs.set(instanceId, sessionId)
+            this.activeSessions.set(instanceId, sessionId)
         } else {
-            this.activeEnvs.set(instanceId, sessionId)
+            this.activeSessions.set(instanceId, sessionId)
         }
     }
 
     private async disconnectEnv(instanceId: EC2.InstanceId): Promise<void> {
-        await this.ssmClient.terminateSessionFromId(this.activeEnvs.get(instanceId)!)
-        this.activeEnvs.delete(instanceId)
+        await this.ssmClient.terminateSessionFromId(this.activeSessions.get(instanceId)!)
+        this.activeSessions.delete(instanceId)
     }
 
     public async closeConnections(): Promise<void> {
-        this.activeEnvs.forEach(async (_sessionId, instanceId) => await this.disconnectEnv(instanceId))
+        this.activeSessions.forEach(async (_sessionId, instanceId) => await this.disconnectEnv(instanceId))
     }
 
     public isConnectedTo(instanceId: EC2.InstanceId): boolean {
-        return this.activeEnvs.has(instanceId)
+        return this.activeSessions.has(instanceId)
     }
 }