Feature/extensible azure resource explorer (#3504)

Extensible Azure Resource Explorer

extensions/azurecore/src/azureResource/tree/accountNotSignedInTreeNode.ts

@@ -7,10 +7,10 @@
 
 import { TreeItem, TreeItemCollapsibleState } from 'vscode';
 import { NodeInfo } from 'sqlops';
-import { TreeNode } from '../../treeNodes';
 import * as nls from 'vscode-nls';
 const localize = nls.loadMessageBundle();
 
+import { TreeNode } from '../treeNode';
 import { AzureResourceItemType } from '../constants';
 
 export class AzureResourceAccountNotSignedInTreeNode extends TreeNode {
@@ -19,11 +19,11 @@ export class AzureResourceAccountNotSignedInTreeNode extends TreeNode {
 	}
 
 	public getTreeItem(): TreeItem | Promise<TreeItem> {
-		let item = new TreeItem(AzureResourceAccountNotSignedInTreeNode.SignInLabel, TreeItemCollapsibleState.None);
+		let item = new TreeItem(AzureResourceAccountNotSignedInTreeNode.signInLabel, TreeItemCollapsibleState.None);
 		item.contextValue = AzureResourceItemType.message;
 		item.command = {
-			title: AzureResourceAccountNotSignedInTreeNode.SignInLabel,
-			command: 'azureresource.signin',
+			title: AzureResourceAccountNotSignedInTreeNode.signInLabel,
+			command: 'azure.resource.signin',
 			arguments: [this]
 		};
 		return item;
@@ -31,7 +31,7 @@ export class AzureResourceAccountNotSignedInTreeNode extends TreeNode {
 
 	public getNodeInfo(): NodeInfo {
 		return {
-			label: AzureResourceAccountNotSignedInTreeNode.SignInLabel,
+			label: AzureResourceAccountNotSignedInTreeNode.signInLabel,
 			isLeaf: true,
 			errorMessage: undefined,
 			metadata: undefined,
@@ -47,5 +47,5 @@ export class AzureResourceAccountNotSignedInTreeNode extends TreeNode {
 		return 'message_accountNotSignedIn';
 	}
 
-	private static readonly SignInLabel = localize('azureResource.tree.accountNotSignedInTreeNode.signIn', 'Sign in to Azure ...');
+	private static readonly signInLabel = localize('azure.resource.tree.accountNotSignedInTreeNode.signInLabel', 'Sign in to Azure ...');
 }

extensions/azurecore/src/azureResource/tree/accountTreeNode.ts

@@ -6,44 +6,59 @@
 'use strict';
 
 import { TreeItem, TreeItemCollapsibleState } from 'vscode';
-import { Account, NodeInfo } from 'sqlops';
-import { TreeNode } from '../../treeNodes';
+import { Account, NodeInfo, AzureResource } from 'sqlops';
+import { TokenCredentials } from 'ms-rest';
+import { AppContext } from '../../appContext';
 import * as nls from 'vscode-nls';
 const localize = nls.loadMessageBundle();
 
+import { azureResource } from '../azure-resource';
+import { TreeNode } from '../treeNode';
+import { AzureResourceCredentialError } from '../errors';
 import { AzureResourceContainerTreeNodeBase } from './baseTreeNodes';
-import { AzureResourceItemType } from '../constants';
+import { AzureResourceItemType, AzureResourceServiceNames } from '../constants';
 import { AzureResourceSubscriptionTreeNode } from './subscriptionTreeNode';
-import { AzureResourceMessageTreeNode } from './messageTreeNode';
+import { AzureResourceMessageTreeNode } from '../messageTreeNode';
 import { AzureResourceErrorMessageUtil } from '../utils';
-import { AzureResourceSubscription } from '../models';
-import { IAzureResourceTreeChangeHandler } from './treeProvider';
+import { IAzureResourceTreeChangeHandler } from './treeChangeHandler';
+import { IAzureResourceSubscriptionService, IAzureResourceSubscriptionFilterService, IAzureResourceTenantService } from '../../azureResource/interfaces';
 
 export class AzureResourceAccountTreeNode extends AzureResourceContainerTreeNodeBase {
 	public constructor(
-		account: Account,
+		public readonly account: Account,
+		appContext: AppContext,
 		treeChangeHandler: IAzureResourceTreeChangeHandler
 	) {
-		super(account, treeChangeHandler, undefined);
+		super(appContext, treeChangeHandler, undefined);
+
+		this._subscriptionService = this.appContext.getService<IAzureResourceSubscriptionService>(AzureResourceServiceNames.subscriptionService);
+		this._subscriptionFilterService = this.appContext.getService<IAzureResourceSubscriptionFilterService>(AzureResourceServiceNames.subscriptionFilterService);
+		this._tenantService = this.appContext.getService<IAzureResourceTenantService>(AzureResourceServiceNames.tenantService);
 
 		this._id = `account_${this.account.key.accountId}`;
+		this.setCacheKey(`${this._id}.subscriptions`);
 		this._label = this.generateLabel();
 	}
 
 	public async getChildren(): Promise<TreeNode[]> {
 		try {
-			let subscriptions: AzureResourceSubscription[] = [];
+			let subscriptions: azureResource.AzureResourceSubscription[] = [];
 
 			if (this._isClearingCache) {
-				const credentials = await this.getCredentials();
-				subscriptions = (await this.servicePool.subscriptionService.getSubscriptions(this.account, credentials)) || <AzureResourceSubscription[]>[];
+				try {
+				    const tokens = await this.appContext.apiWrapper.getSecurityToken(this.account, AzureResource.ResourceManagement);
 
-				let cache = this.getCache<AzureResourceSubscriptionsCache>();
-				if (!cache) {
-					cache = { subscriptions: { } };
+					for (const tenant of this.account.properties.tenants) {
+						const token = tokens[tenant.id].token;
+						const tokenType = tokens[tenant.id].tokenType;
+
+						subscriptions.push(...(await this._subscriptionService.getSubscriptions(this.account, new TokenCredentials(token, tokenType)) || <azureResource.AzureResourceSubscription[]>[]));
+					}
+				} catch (error) {
+					throw new AzureResourceCredentialError(localize('azure.resource.tree.accountTreeNode.credentialError', 'Failed to get credential for account {0}. Please refresh the account.', this.account.key.accountId), error);
 				}
-				cache.subscriptions[this.account.key.accountId] = subscriptions;
-				this.updateCache<AzureResourceSubscriptionsCache>(cache);
+
+				this.updateCache<azureResource.AzureResourceSubscription[]>(subscriptions);
 
 				this._isClearingCache = false;
 			} else {
@@ -52,8 +67,8 @@ export class AzureResourceAccountTreeNode extends AzureResourceContainerTreeNode
 
 			this._totalSubscriptionCount = subscriptions.length;
 
-			let selectedSubscriptions = await this.servicePool.subscriptionFilterService.getSelectedSubscriptions(this.account);
-			let selectedSubscriptionIds = (selectedSubscriptions || <AzureResourceSubscription[]>[]).map((subscription) => subscription.id);
+			const selectedSubscriptions = await this._subscriptionFilterService.getSelectedSubscriptions(this.account);
+			const selectedSubscriptionIds = (selectedSubscriptions || <azureResource.AzureResourceSubscription[]>[]).map((subscription) => subscription.id);
 			if (selectedSubscriptionIds.length > 0) {
 				subscriptions = subscriptions.filter((subscription) => selectedSubscriptionIds.indexOf(subscription.id) !== -1);
 				this._selectedSubscriptionCount = selectedSubscriptionIds.length;
@@ -65,31 +80,36 @@ export class AzureResourceAccountTreeNode extends AzureResourceContainerTreeNode
 			this.refreshLabel();
 
 			if (subscriptions.length === 0) {
-				return [AzureResourceMessageTreeNode.create(AzureResourceAccountTreeNode.NoSubscriptions, this)];
+				return [AzureResourceMessageTreeNode.create(AzureResourceAccountTreeNode.noSubscriptionsLabel, this)];
 			} else {
-				return subscriptions.map((subscription) => new AzureResourceSubscriptionTreeNode(subscription, this.account, this.treeChangeHandler, this));
+				return await Promise.all(subscriptions.map(async (subscription) => {
+					const tenantId = await this._tenantService.getTenantId(subscription);
+
+					return new AzureResourceSubscriptionTreeNode(this.account, subscription, tenantId, this.appContext, this.treeChangeHandler, this);
+				}));
 			}
 		} catch (error) {
-			return [AzureResourceMessageTreeNode.create(AzureResourceErrorMessageUtil.getErrorMessage(error), this)];
+			if (error instanceof AzureResourceCredentialError) {
+				this.appContext.apiWrapper.showErrorMessage(error.message);
+
+				this.appContext.apiWrapper.executeCommand('azure.resource.signin');
+			} else {
+				return [AzureResourceMessageTreeNode.create(AzureResourceErrorMessageUtil.getErrorMessage(error), this)];
+			}
 		}
 	}
 
-	public async getCachedSubscriptions(): Promise<AzureResourceSubscription[]> {
-		const subscriptions: AzureResourceSubscription[] = [];
-		const cache = this.getCache<AzureResourceSubscriptionsCache>();
-		if (cache) {
-			subscriptions.push(...cache.subscriptions[this.account.key.accountId]);
-		}
-		return subscriptions;
+	public async getCachedSubscriptions(): Promise<azureResource.AzureResourceSubscription[]> {
+		return this.getCache<azureResource.AzureResourceSubscription[]>();
 	}
 
 	public getTreeItem(): TreeItem | Promise<TreeItem> {
-		let item = new TreeItem(this._label, TreeItemCollapsibleState.Collapsed);
+		const item = new TreeItem(this._label, TreeItemCollapsibleState.Collapsed);
 		item.id = this._id;
 		item.contextValue = AzureResourceItemType.account;
 		item.iconPath = {
-			dark: this.servicePool.contextService.getAbsolutePath('resources/dark/account_inverse.svg'),
-			light: this.servicePool.contextService.getAbsolutePath('resources/light/account.svg')
+			dark: this.appContext.extensionContext.asAbsolutePath('resources/dark/account_inverse.svg'),
+			light: this.appContext.extensionContext.asAbsolutePath('resources/light/account.svg')
 		};
 		return item;
 	}
@@ -128,10 +148,6 @@ export class AzureResourceAccountTreeNode extends AzureResourceContainerTreeNode
 		}
 	}
 
-	protected get cacheKey(): string {
-		return 'azureResource.cache.subscriptions';
-	}
-
 	private generateLabel(): string {
 		let label = `${this.account.displayInfo.displayName} (${this.account.key.accountId})`;
 
@@ -142,14 +158,14 @@ export class AzureResourceAccountTreeNode extends AzureResourceContainerTreeNode
 		return label;
 	}
 
+	private _subscriptionService: IAzureResourceSubscriptionService = undefined;
+	private _subscriptionFilterService: IAzureResourceSubscriptionFilterService = undefined;
+	private _tenantService: IAzureResourceTenantService = undefined;
+
 	private _id: string = undefined;
 	private _label: string = undefined;
 	private _totalSubscriptionCount = 0;
 	private _selectedSubscriptionCount = 0;
 
-	private static readonly NoSubscriptions = localize('azureResource.tree.accountTreeNode.noSubscriptions', 'No Subscriptions found.');
-}
-
-interface AzureResourceSubscriptionsCache {
-	subscriptions: { [accountId: string]: AzureResourceSubscription[] };
-}
+	private static readonly noSubscriptionsLabel = localize('azure.resource.tree.accountTreeNode.noSubscriptionsLabel', 'No Subscriptions found.');
+}

extensions/azurecore/src/azureResource/tree/baseTreeNodes.ts

@@ -5,16 +5,16 @@
 
 'use strict';
 
-import * as sqlops from 'sqlops';
-import { ServiceClientCredentials } from 'ms-rest';
-import { TreeNode } from '../../treeNodes';
+import { AppContext } from '../../appContext';
 
-import { AzureResourceServicePool } from '../servicePool';
-import { AzureResourceCredentialError } from '../errors';
+import { TreeNode } from '../treeNode';
 import { IAzureResourceTreeChangeHandler } from './treeChangeHandler';
+import { IAzureResourceCacheService } from '../../azureResource/interfaces';
+import { AzureResourceServiceNames } from '../constants';
 
 export abstract class AzureResourceTreeNodeBase extends TreeNode {
 	public constructor(
+		public readonly appContext: AppContext,
 		public readonly treeChangeHandler: IAzureResourceTreeChangeHandler,
 		parent: TreeNode
 	) {
@@ -22,17 +22,17 @@ export abstract class AzureResourceTreeNodeBase extends TreeNode {
 
 		this.parent = parent;
 	}
-
-	public readonly servicePool = AzureResourceServicePool.getInstance();
 }
 
 export abstract class AzureResourceContainerTreeNodeBase extends AzureResourceTreeNodeBase {
 	public constructor(
-		public readonly account: sqlops.Account,
+		appContext: AppContext,
 		treeChangeHandler: IAzureResourceTreeChangeHandler,
 		parent: TreeNode
 	) {
-		super(treeChangeHandler, parent);
+		super(appContext, treeChangeHandler, parent);
+
+		this._cacheService = this.appContext.getService<IAzureResourceCacheService>(AzureResourceServiceNames.cacheService);
 	}
 
 	public clearCache(): void {
@@ -43,29 +43,19 @@ export abstract class AzureResourceContainerTreeNodeBase extends AzureResourceTr
 		return this._isClearingCache;
 	}
 
-	protected async getCredentials(): Promise<ServiceClientCredentials[]> {
-		try {
-			return await this.servicePool.credentialService.getCredentials(this.account, sqlops.AzureResource.ResourceManagement);
-		} catch (error) {
-			if (error instanceof AzureResourceCredentialError) {
-				this.servicePool.contextService.showErrorMessage(error.message);
-
-				this.servicePool.contextService.executeCommand('azureresource.signin');
-			} else {
-				throw error;
-			}
-		}
-	}
+	protected setCacheKey(id: string): void {
+        this._cacheKey = this._cacheService.generateKey(id);
+    }
 
 	protected updateCache<T>(cache: T): void {
-		this.servicePool.cacheService.update<T>(this.cacheKey, cache);
+		this._cacheService.update<T>(this._cacheKey, cache);
 	}
 
 	protected getCache<T>(): T {
-		return this.servicePool.cacheService.get<T>(this.cacheKey);
+		return this._cacheService.get<T>(this._cacheKey);
 	}
 
-	protected abstract get cacheKey(): string;
-
 	protected _isClearingCache = true;
+	private _cacheService: IAzureResourceCacheService = undefined;
+	private _cacheKey: string = undefined;
 }

extensions/azurecore/src/azureResource/tree/databaseContainerTreeNode.ts

@@ -1,103 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the Source EULA. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-'use strict';
-
-import { TreeItem, TreeItemCollapsibleState } from 'vscode';
-import { Account, NodeInfo } from 'sqlops';
-import { TreeNode } from '../../treeNodes';
-import * as nls from 'vscode-nls';
-const localize = nls.loadMessageBundle();
-
-import { AzureResourceContainerTreeNodeBase } from './baseTreeNodes';
-import { AzureResourceItemType } from '../constants';
-import { AzureResourceErrorMessageUtil } from '../utils';
-import { AzureResourceDatabaseTreeNode } from './databaseTreeNode';
-import { AzureResourceMessageTreeNode } from './messageTreeNode';
-import { AzureResourceSubscription, AzureResourceDatabase } from '../models';
-import { IAzureResourceTreeChangeHandler } from './treeProvider';
-
-export class AzureResourceDatabaseContainerTreeNode extends AzureResourceContainerTreeNodeBase {
-	public constructor(
-		public readonly subscription: AzureResourceSubscription,
-		account: Account,
-		treeChangeHandler: IAzureResourceTreeChangeHandler,
-		parent: TreeNode
-	) {
-		super(account, treeChangeHandler, parent);
-	}
-
-	public async getChildren(): Promise<TreeNode[]> {
-		try {
-			let databases: AzureResourceDatabase[] = [];
-
-			if (this._isClearingCache) {
-				let credentials = await this.getCredentials();
-				databases = (await this.servicePool.databaseService.getDatabases(this.subscription, credentials)) || <AzureResourceDatabase[]>[];
-
-				let cache = this.getCache<AzureResourceDatabasesCache>();
-				if (!cache) {
-					cache = { databases: { } };
-				}
-				cache.databases[this.subscription.id] = databases;
-				this.updateCache(cache);
-
-				this._isClearingCache = false;
-			} else {
-				const cache = this.getCache<AzureResourceDatabasesCache>();
-				if (cache) {
-					databases = cache.databases[this.subscription.id] || <AzureResourceDatabase[]>[];
-				}
-			}
-
-			if (databases.length === 0) {
-				return [AzureResourceMessageTreeNode.create(AzureResourceDatabaseContainerTreeNode.NoDatabases, this)];
-			} else {
-				return databases.map((database) => new AzureResourceDatabaseTreeNode(database, this.treeChangeHandler, this));
-			}
-		} catch (error) {
-			return [AzureResourceMessageTreeNode.create(AzureResourceErrorMessageUtil.getErrorMessage(error), this)];
-		}
-	}
-
-	public getTreeItem(): TreeItem | Promise<TreeItem> {
-		let item = new TreeItem(AzureResourceDatabaseContainerTreeNode.Label, TreeItemCollapsibleState.Collapsed);
-		item.contextValue = AzureResourceItemType.databaseContainer;
-		item.iconPath = {
-			dark: this.servicePool.contextService.getAbsolutePath('resources/dark/folder_inverse.svg'),
-			light: this.servicePool.contextService.getAbsolutePath('resources/light/folder.svg')
-		};
-		return item;
-	}
-
-	public getNodeInfo(): NodeInfo {
-		return {
-			label: AzureResourceDatabaseContainerTreeNode.Label,
-			isLeaf: false,
-			errorMessage: undefined,
-			metadata: undefined,
-			nodePath: this.generateNodePath(),
-			nodeStatus: undefined,
-			nodeType: AzureResourceItemType.databaseContainer,
-			nodeSubType: undefined,
-			iconType: AzureResourceItemType.databaseContainer
-		};
-	}
-
-	public get nodePathValue(): string {
-		return 'databaseContainer';
-	}
-
-	protected get cacheKey(): string {
-		return 'azureResource.cache.databases';
-	}
-
-	private static readonly Label = localize('azureResource.tree.databaseContainerTreeNode.label', 'SQL Databases');
-	private static readonly NoDatabases = localize('azureResource.tree.databaseContainerTreeNode.noDatabases', 'No SQL Databases found.');
-}
-
-interface AzureResourceDatabasesCache {
-	databases: { [subscriptionId: string]: AzureResourceDatabase[] };
-}

extensions/azurecore/src/azureResource/tree/databaseServerContainerTreeNode.ts

@@ -1,103 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the Source EULA. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-'use strict';
-
-import { TreeItem, TreeItemCollapsibleState } from 'vscode';
-import { Account, NodeInfo } from 'sqlops';
-import { TreeNode } from '../../treeNodes';
-import * as nls from 'vscode-nls';
-const localize = nls.loadMessageBundle();
-
-import { AzureResourceContainerTreeNodeBase } from './baseTreeNodes';
-import { AzureResourceItemType } from '../constants';
-import { AzureResourceMessageTreeNode } from './messageTreeNode';
-import { AzureResourceErrorMessageUtil } from '../utils';
-import { AzureResourceSubscription, AzureResourceDatabaseServer } from '../models';
-import { AzureResourceDatabaseServerTreeNode } from './databaseServerTreeNode';
-import { IAzureResourceTreeChangeHandler } from './treeProvider';
-
-export class AzureResourceDatabaseServerContainerTreeNode extends AzureResourceContainerTreeNodeBase {
-	public constructor(
-		public readonly subscription: AzureResourceSubscription,
-		account: Account,
-		treeChangeHandler: IAzureResourceTreeChangeHandler,
-		parent: TreeNode
-	) {
-		super(account, treeChangeHandler, parent);
-	}
-
-	public async getChildren(): Promise<TreeNode[]> {
-		try {
-			let databaseServers: AzureResourceDatabaseServer[] = [];
-
-			if (this._isClearingCache) {
-				let credentials = await this.getCredentials();
-				databaseServers = (await this.servicePool.databaseServerService.getDatabaseServers(this.subscription, credentials)) || <AzureResourceDatabaseServer[]>[];
-
-				let cache = this.getCache<AzureResourceDatabaseServersCache>();
-				if (!cache) {
-					cache = { databaseServers: { } };
-				}
-				cache.databaseServers[this.subscription.id] = databaseServers;
-				this.updateCache<AzureResourceDatabaseServersCache>(cache);
-
-				this._isClearingCache = false;
-			} else {
-				const cache = this.getCache<AzureResourceDatabaseServersCache>();
-				if (cache) {
-					databaseServers = cache.databaseServers[this.subscription.id] || <AzureResourceDatabaseServer[]>[];
-				}
-			}
-
-			if (databaseServers.length === 0) {
-				return [AzureResourceMessageTreeNode.create(AzureResourceDatabaseServerContainerTreeNode.NoDatabaseServers, this)];
-			} else {
-				return databaseServers.map((server) => new AzureResourceDatabaseServerTreeNode(server, this.treeChangeHandler, this));
-			}
-		} catch (error) {
-			return [AzureResourceMessageTreeNode.create(AzureResourceErrorMessageUtil.getErrorMessage(error), this)];
-		}
-	}
-
-	public getTreeItem(): TreeItem | Promise<TreeItem> {
-		let item = new TreeItem(AzureResourceDatabaseServerContainerTreeNode.Label, TreeItemCollapsibleState.Collapsed);
-		item.contextValue = AzureResourceItemType.databaseServerContainer;
-		item.iconPath = {
-			dark: this.servicePool.contextService.getAbsolutePath('resources/dark/folder_inverse.svg'),
-			light: this.servicePool.contextService.getAbsolutePath('resources/light/folder.svg')
-		};
-		return item;
-	}
-
-	public getNodeInfo(): NodeInfo {
-		return {
-			label: AzureResourceDatabaseServerContainerTreeNode.Label,
-			isLeaf: false,
-			errorMessage: undefined,
-			metadata: undefined,
-			nodePath: this.generateNodePath(),
-			nodeStatus: undefined,
-			nodeType: AzureResourceItemType.databaseServerContainer,
-			nodeSubType: undefined,
-			iconType: AzureResourceItemType.databaseServerContainer
-		};
-	}
-
-	public get nodePathValue(): string {
-		return 'databaseServerContainer';
-	}
-
-	protected get cacheKey(): string {
-		return 'azureResource.cache.databaseServers';
-	}
-
-	private static readonly Label = localize('azureResource.tree.databaseServerContainerTreeNode.label', 'SQL Servers');
-	private static readonly NoDatabaseServers = localize('azureResource.tree.databaseContainerTreeNode.noDatabaseServers', 'No SQL Servers found.');
-}
-
-interface AzureResourceDatabaseServersCache {
-	databaseServers: { [subscriptionId: string]: AzureResourceDatabaseServer[] };
-}

extensions/azurecore/src/azureResource/tree/databaseServerTreeNode.ts

@@ -1,57 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the Source EULA. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-'use strict';
-
-import { TreeItem, TreeItemCollapsibleState } from 'vscode';
-import { NodeInfo } from 'sqlops';
-import { TreeNode } from '../../treeNodes';
-
-import { AzureResourceTreeNodeBase } from './baseTreeNodes';
-import { AzureResourceItemType } from '../constants';
-import { AzureResourceDatabaseServer } from '../models';
-import { IAzureResourceTreeChangeHandler } from './treeProvider';
-
-export class AzureResourceDatabaseServerTreeNode extends AzureResourceTreeNodeBase {
-	public constructor(
-		public readonly databaseServer: AzureResourceDatabaseServer,
-		treeChangeHandler: IAzureResourceTreeChangeHandler,
-		parent: TreeNode
-	) {
-		super(treeChangeHandler, parent);
-	}
-
-	public async getChildren(): Promise<TreeNode[]> {
-		return [];
-	}
-
-	public getTreeItem(): TreeItem | Promise<TreeItem> {
-		let item = new TreeItem(this.databaseServer.name, TreeItemCollapsibleState.None);
-		item.contextValue = AzureResourceItemType.databaseServer;
-		item.iconPath = {
-			dark: this.servicePool.contextService.getAbsolutePath('resources/dark/sql_server_inverse.svg'),
-			light: this.servicePool.contextService.getAbsolutePath('resources/light/sql_server.svg')
-		};
-		return item;
-	}
-
-	public getNodeInfo(): NodeInfo {
-		return {
-			label: this.databaseServer.name,
-			isLeaf: true,
-			errorMessage: undefined,
-			metadata: undefined,
-			nodePath: this.generateNodePath(),
-			nodeStatus: undefined,
-			nodeType: AzureResourceItemType.databaseServer,
-			nodeSubType: undefined,
-			iconType: AzureResourceItemType.databaseServer
-		};
-	}
-
-	public get nodePathValue(): string {
-		return `databaseServer_${this.databaseServer.name}`;
-	}
-}

extensions/azurecore/src/azureResource/tree/databaseTreeNode.ts

@@ -1,61 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the Source EULA. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-'use strict';
-
-import { TreeItem, TreeItemCollapsibleState } from 'vscode';
-import { NodeInfo } from 'sqlops';
-import { TreeNode } from '../../treeNodes';
-
-import { AzureResourceTreeNodeBase } from './baseTreeNodes';
-import { AzureResourceItemType } from '../constants';
-import { AzureResourceDatabase } from '../models';
-import { IAzureResourceTreeChangeHandler } from './treeProvider';
-
-export class AzureResourceDatabaseTreeNode extends AzureResourceTreeNodeBase {
-	public constructor(
-		public readonly database: AzureResourceDatabase,
-		treeChangeHandler: IAzureResourceTreeChangeHandler,
-		parent: TreeNode
-	) {
-		super(treeChangeHandler, parent);
-
-		this._label = `${this.database.name} (${this.database.serverName})`;
-	}
-
-	public async getChildren(): Promise<TreeNode[]> {
-		return [];
-	}
-
-	public getTreeItem(): TreeItem | Promise<TreeItem> {
-		let item = new TreeItem(this._label, TreeItemCollapsibleState.None);
-		item.contextValue = AzureResourceItemType.database;
-		item.iconPath = {
-			dark: this.servicePool.contextService.getAbsolutePath('resources/dark/sql_database_inverse.svg'),
-			light: this.servicePool.contextService.getAbsolutePath('resources/light/sql_database.svg')
-		};
-		return item;
-	}
-
-	public getNodeInfo(): NodeInfo {
-		return {
-			label: this._label,
-			isLeaf: true,
-			errorMessage: undefined,
-			metadata: undefined,
-			nodePath: this.generateNodePath(),
-			nodeStatus: undefined,
-			nodeType: AzureResourceItemType.database,
-			nodeSubType: undefined,
-			iconType: AzureResourceItemType.database
-		};
-	}
-
-	public get nodePathValue(): string {
-		return `database_${this.database.name}`;
-	}
-
-	private _label: string = undefined;
-}

extensions/azurecore/src/azureResource/tree/messageTreeNode.ts

@@ -1,60 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the Source EULA. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-'use strict';
-
-import { TreeItem, TreeItemCollapsibleState } from 'vscode';
-import { NodeInfo } from 'sqlops';
-import { TreeNode } from '../../treeNodes';
-
-import { AzureResourceItemType } from '../constants';
-
-export class AzureResourceMessageTreeNode extends TreeNode {
-	public constructor(
-		public readonly message: string,
-		parent: TreeNode
-	) {
-		super();
-
-		this.parent = parent;
-		this._id = `message_${AzureResourceMessageTreeNode._messageNum++}`;
-	}
-
-	public static create(message: string, parent: TreeNode): AzureResourceMessageTreeNode {
-		return new AzureResourceMessageTreeNode(message, parent);
-	}
-
-	public getChildren(): TreeNode[] | Promise<TreeNode[]> {
-		return [];
-	}
-
-	public getTreeItem(): TreeItem | Promise<TreeItem> {
-		let item = new TreeItem(this.message, TreeItemCollapsibleState.None);
-		item.contextValue = AzureResourceItemType.message;
-		return item;
-	}
-
-	public getNodeInfo(): NodeInfo {
-		return {
-			label: this.message,
-			isLeaf: true,
-			errorMessage: undefined,
-			metadata: undefined,
-			nodePath: this.generateNodePath(),
-			nodeStatus: undefined,
-			nodeType: AzureResourceItemType.message,
-			nodeSubType: undefined,
-			iconType: AzureResourceItemType.message
-		};
-	}
-
-	public get nodePathValue(): string {
-		return this._id;
-	}
-
-	private _id: string;
-
-	private static _messageNum: number = 0;
-}

extensions/azurecore/src/azureResource/tree/subscriptionTreeNode.ts

@@ -7,38 +7,66 @@
 
 import { TreeItem, TreeItemCollapsibleState } from 'vscode';
 import { Account, NodeInfo } from 'sqlops';
-import { TreeNode } from '../../treeNodes';
+import { AppContext } from '../../appContext';
+import * as nls from 'vscode-nls';
+const localize = nls.loadMessageBundle();
 
-import { AzureResourceTreeNodeBase, AzureResourceContainerTreeNodeBase } from './baseTreeNodes';
+import { azureResource } from '../azure-resource';
+import { TreeNode } from '../treeNode';
+import { IAzureResourceNodeWithProviderId } from '../interfaces';
+import { AzureResourceContainerTreeNodeBase } from './baseTreeNodes';
 import { AzureResourceItemType } from '../constants';
-import { AzureResourceDatabaseContainerTreeNode } from './databaseContainerTreeNode';
-import { AzureResourceDatabaseServerContainerTreeNode } from './databaseServerContainerTreeNode';
-import { AzureResourceSubscription } from '../models';
 import { IAzureResourceTreeChangeHandler } from './treeChangeHandler';
+import { AzureResourceMessageTreeNode } from '../messageTreeNode';
+import { AzureResourceErrorMessageUtil } from '../utils';
+import { AzureResourceService } from '../resourceService';
+import { AzureResourceResourceTreeNode } from '../resourceTreeNode';
 
-export class AzureResourceSubscriptionTreeNode extends AzureResourceTreeNodeBase {
+export class AzureResourceSubscriptionTreeNode extends AzureResourceContainerTreeNodeBase {
 	public constructor(
-		public readonly subscription: AzureResourceSubscription,
-		account: Account,
+		public readonly account: Account,
+		public readonly subscription: azureResource.AzureResourceSubscription,
+		public readonly tenatId: string,
+		appContext: AppContext,
 		treeChangeHandler: IAzureResourceTreeChangeHandler,
 		parent: TreeNode
 	) {
-		super(treeChangeHandler, parent);
+		super(appContext, treeChangeHandler, parent);
 
-		this._children.push(new AzureResourceDatabaseContainerTreeNode(subscription, account, treeChangeHandler, this));
-		this._children.push(new AzureResourceDatabaseServerContainerTreeNode(subscription, account, treeChangeHandler, this));
+		this._id = `account_${this.account.key.accountId}.subscription_${this.subscription.id}.tenant_${this.tenatId}`;
+		this.setCacheKey(`${this._id}.resources`);
 	}
 
 	public async getChildren(): Promise<TreeNode[]> {
-		return this._children;
+		try {
+			const resourceService = AzureResourceService.getInstance();
+
+			const children: IAzureResourceNodeWithProviderId[] = [];
+
+			for (const resourceProviderId of await resourceService.listResourceProviderIds()) {
+				children.push(...await resourceService.getRootChildren(resourceProviderId, this.account, this.subscription, this.tenatId));
+			}
+
+			if (children.length === 0) {
+				return [AzureResourceMessageTreeNode.create(AzureResourceSubscriptionTreeNode.noResourcesLabel, this)];
+			} else {
+				return children.map((child) => {
+					// To make tree node's id unique, otherwise, treeModel.js would complain 'item already registered'
+					child.resourceNode.treeItem.id = `${this._id}.${child.resourceNode.treeItem.id}`;
+					return new AzureResourceResourceTreeNode(child, this);
+				});
+			}
+		} catch (error) {
+			return [AzureResourceMessageTreeNode.create(AzureResourceErrorMessageUtil.getErrorMessage(error), this)];
+		}
 	}
 
 	public getTreeItem(): TreeItem | Promise<TreeItem> {
-		let item = new TreeItem(this.subscription.name, TreeItemCollapsibleState.Collapsed);
+		const item = new TreeItem(this.subscription.name, TreeItemCollapsibleState.Collapsed);
 		item.contextValue = AzureResourceItemType.subscription;
 		item.iconPath = {
-			dark: this.servicePool.contextService.getAbsolutePath('resources/dark/subscription_inverse.svg'),
-			light: this.servicePool.contextService.getAbsolutePath('resources/light/subscription.svg')
+			dark: this.appContext.extensionContext.asAbsolutePath('resources/dark/subscription_inverse.svg'),
+			light: this.appContext.extensionContext.asAbsolutePath('resources/light/subscription.svg')
 		};
 		return item;
 	}
@@ -58,8 +86,10 @@ export class AzureResourceSubscriptionTreeNode extends AzureResourceTreeNodeBase
 	}
 
 	public get nodePathValue(): string {
-		return `subscription_${this.subscription.id}`;
+        return this._id;
 	}
 
-	private _children: AzureResourceContainerTreeNodeBase[] = [];
+	private _id: string = undefined;
+
+	private static readonly noResourcesLabel = localize('azure.resource.tree.subscriptionTreeNode.noResourcesLabel', 'No Resources found.');
 }

extensions/azurecore/src/azureResource/tree/treeChangeHandler.ts

@@ -5,7 +5,7 @@
 
 'use strict';
 
-import { TreeNode } from '../../treeNodes';
+import { TreeNode } from '../treeNode';
 
 export interface IAzureResourceTreeChangeHandler {
 	notifyNodeChanged(node: TreeNode): void;

extensions/azurecore/src/azureResource/tree/treeProvider.ts

@@ -6,26 +6,25 @@
 'use strict';
 
 import { TreeDataProvider, EventEmitter, Event, TreeItem } from 'vscode';
-import { DidChangeAccountsParams } from 'sqlops';
-import { TreeNode } from '../../treeNodes';
 import { setInterval, clearInterval } from 'timers';
+import { AppContext } from '../../appContext';
 import * as nls from 'vscode-nls';
 const localize = nls.loadMessageBundle();
 
-import { AzureResourceServicePool } from '../servicePool';
+import { TreeNode } from '../treeNode';
 import { AzureResourceAccountTreeNode } from './accountTreeNode';
 import { AzureResourceAccountNotSignedInTreeNode } from './accountNotSignedInTreeNode';
-import { AzureResourceMessageTreeNode } from './messageTreeNode';
-import { AzureResourceContainerTreeNodeBase, AzureResourceTreeNodeBase } from './baseTreeNodes';
+import { AzureResourceMessageTreeNode } from '../messageTreeNode';
+import { AzureResourceContainerTreeNodeBase } from './baseTreeNodes';
 import { AzureResourceErrorMessageUtil } from '../utils';
-
-export interface IAzureResourceTreeChangeHandler {
-	notifyNodeChanged(node: TreeNode): void;
-}
+import { IAzureResourceTreeChangeHandler } from './treeChangeHandler';
+import { IAzureResourceAccountService } from '../../azureResource/interfaces';
+import { AzureResourceServiceNames } from '../constants';
 
 export class AzureResourceTreeProvider implements TreeDataProvider<TreeNode>, IAzureResourceTreeChangeHandler {
-	public constructor() {
-		AzureResourceServicePool.getInstance().accountService.onDidChangeAccounts((e: DidChangeAccountsParams) => { this._onDidChangeTreeData.fire(undefined); });
+	public constructor(
+		public readonly appContext: AppContext
+	) {
 	}
 
 	public async getChildren(element?: TreeNode): Promise<TreeNode[]> {
@@ -37,7 +36,7 @@ export class AzureResourceTreeProvider implements TreeDataProvider<TreeNode>, IA
 			this._loadingTimer = setInterval(async () => {
 				try {
 					// Call sqlops.accounts.getAllAccounts() to determine whether the system has been initialized.
-					await AzureResourceServicePool.getInstance().accountService.getAccounts();
+					await this.appContext.getService<IAzureResourceAccountService>(AzureResourceServiceNames.accountService).getAccounts();
 
 					// System has been initialized
 					this.isSystemInitialized = true;
@@ -51,16 +50,16 @@ export class AzureResourceTreeProvider implements TreeDataProvider<TreeNode>, IA
 					// System not initialized yet
 					this.isSystemInitialized = false;
 				}
-			}, AzureResourceTreeProvider.LoadingTimerInterval);
+			}, AzureResourceTreeProvider.loadingTimerInterval);
 
-			return [AzureResourceMessageTreeNode.create(AzureResourceTreeProvider.Loading, undefined)];
+			return [AzureResourceMessageTreeNode.create(AzureResourceTreeProvider.loadingLabel, undefined)];
 		}
 
 		try {
-			const accounts = await AzureResourceServicePool.getInstance().accountService.getAccounts();
+			const accounts = await this.appContext.getService<IAzureResourceAccountService>(AzureResourceServiceNames.accountService).getAccounts();
 
 			if (accounts && accounts.length > 0) {
-				return accounts.map((account) => new AzureResourceAccountTreeNode(account, this));
+				return accounts.map((account) => new AzureResourceAccountTreeNode(account, this.appContext, this));
 			} else {
 				return [new AzureResourceAccountNotSignedInTreeNode()];
 			}
@@ -96,6 +95,6 @@ export class AzureResourceTreeProvider implements TreeDataProvider<TreeNode>, IA
 	private _loadingTimer: NodeJS.Timer = undefined;
 	private _onDidChangeTreeData = new EventEmitter<TreeNode>();
 
-	private static readonly Loading = localize('azureResource.tree.treeProvider.loading', 'Loading ...');
-	private static readonly LoadingTimerInterval = 5000;
+	private static readonly loadingLabel = localize('azure.resource.tree.treeProvider.loadingLabel', 'Loading ...');
+	private static readonly loadingTimerInterval = 5000;
 }