# *****************************************************************************
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.
#
# ******************************************************************************

from azure.common.client_factory import get_client_from_auth_file
from azure.mgmt.authorization import AuthorizationManagementClient
from azure.mgmt.compute import ComputeManagementClient
from azure.mgmt.resource import ResourceManagementClient
from azure.mgmt.network import NetworkManagementClient
from azure.mgmt.storage import StorageManagementClient
from azure.storage.blob import BlockBlobService
from azure.mgmt.datalake.store import DataLakeStoreAccountManagementClient
from azure.datalake.store import core, lib
from azure.graphrbac import GraphRbacManagementClient
from azure.common.credentials import ServicePrincipalCredentials
import azure.common.exceptions as AzureExceptions
import logging
import traceback
import sys
import os
import json


class AzureMeta:
    def __init__(self):
        os.environ['AZURE_AUTH_LOCATION'] = '/root/azure_auth.json'
        self.compute_client = get_client_from_auth_file(ComputeManagementClient)
        self.resource_client = get_client_from_auth_file(ResourceManagementClient)
        self.network_client = get_client_from_auth_file(NetworkManagementClient)
        self.storage_client = get_client_from_auth_file(StorageManagementClient)
        self.datalake_client = get_client_from_auth_file(DataLakeStoreAccountManagementClient)
        self.authorization_client = get_client_from_auth_file(AuthorizationManagementClient)
        self.sp_creds = json.loads(open(os.environ['AZURE_AUTH_LOCATION']).read())
        self.dl_filesystem_creds = lib.auth(tenant_id=json.dumps(self.sp_creds['tenantId']).replace('"', ''),
                                            client_secret=json.dumps(self.sp_creds['clientSecret']).replace('"', ''),
                                            client_id=json.dumps(self.sp_creds['clientId']).replace('"', ''),
                                            resource='https://datalake.azure.net/')

    def get_resource_group(self, resource_group_name):
        try:
            result = self.resource_client.resource_groups.get(resource_group_name)
            return result
        except AzureExceptions.CloudError as err:
            if err.status_code == 404:
                return ''
        except Exception as err:
            logging.info(
                "Unable to get Resource Group: " + str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout))
            append_result(str({"error": "Unable to get Resource Group",
                               "error_message": str(err) + "\n Traceback: " + traceback.print_exc(
                                   file=sys.stdout)}))
            traceback.print_exc(file=sys.stdout)

    def get_vpc(self, resource_group_name, vpc_name):
        try:
            result = self.network_client.virtual_networks.get(resource_group_name, vpc_name)
            return result
        except AzureExceptions.CloudError as err:
            if err.status_code == 404:
                return ''
        except Exception as err:
            logging.info(
                "Unable to get Virtual Network: " + str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout))
            append_result(str({"error": "Unable to get Virtual Network",
                               "error_message": str(err) + "\n Traceback: " + traceback.print_exc(
                                   file=sys.stdout)}))
            traceback.print_exc(file=sys.stdout)

    def get_subnet(self, resource_group_name, vpc_name, subnet_name):
        try:
            result = self.network_client.subnets.get(resource_group_name, vpc_name, subnet_name)
            return result
        except AzureExceptions.CloudError as err:
            if err.status_code == 404:
                return ''
        except Exception as err:
            logging.info(
                "Unable to get Subnet: " + str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout))
            append_result(str({"error": "Unable to get Subnet",
                               "error_message": str(err) + "\n Traceback: " + traceback.print_exc(
                                   file=sys.stdout)}))
            traceback.print_exc(file=sys.stdout)

    def get_security_group(self, resource_group_name, network_security_group_name):
        try:
            result = self.network_client.network_security_groups.get(
                resource_group_name,
                network_security_group_name
            )
            return result
        except AzureExceptions.CloudError as err:
            if err.status_code == 404:
                return ''
        except Exception as err:
            logging.info(
                "Unable to get security group: " + str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout))
            append_result(str({"error": "Unable to get security group",
                               "error_message": str(err) + "\n Traceback: " + traceback.print_exc(
                                   file=sys.stdout)}))
            traceback.print_exc(file=sys.stdout)

    def get_security_group_rule(self, resource_group_name, network_security_group_name, rule_name):
        try:
            result = self.network_client.security_rules.get(resource_group_name, network_security_group_name,
                                                            rule_name)
            return result
        except AzureExceptions.CloudError as err:
            if err.status_code == 404:
                return ''
        except Exception as err:
            logging.info(
                "Unable to get Security Group rule: " + str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout))
            append_result(str({"error": "Unable to get Security Group rule",
                               "error_message": str(err) + "\n Traceback: " + traceback.print_exc(
                                   file=sys.stdout)}))
            traceback.print_exc(file=sys.stdout)

    def list_subnets(self, resource_group_name, vpc_name):
        try:
            result = self.network_client.subnets.list(resource_group_name, vpc_name)
            return result
        except AzureExceptions.CloudError as err:
            if err.status_code == 404:
                return ''
        except Exception as err:
            logging.info(
                "Unable to get list of Subnets: " + str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout))
            append_result(str({"error": "Unable to get list of Subnets",
                               "error_message": str(err) + "\n Traceback: " + traceback.print_exc(
                                   file=sys.stdout)}))
            traceback.print_exc(file=sys.stdout)

    def get_instance(self, resource_group_name, instance_name):
        try:
            result = self.compute_client.virtual_machines.get(resource_group_name, instance_name)
            return result
        except AzureExceptions.CloudError as err:
            if err.status_code == 404:
                return ''
        except Exception as err:
            logging.info(
                "Unable to get instance: " + str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout))
            append_result(str({"error": "Unable to get instance",
                               "error_message": str(err) + "\n Traceback: " + traceback.print_exc(
                                   file=sys.stdout)}))
            traceback.print_exc(file=sys.stdout)

    def get_instances_name_by_tag(self, resource_group_name, tag, value):
        try:
            list = []
            for vm in self.compute_client.virtual_machines.list(resource_group_name):
                if vm.tags.get(tag) == value:
                    list.append(vm.name)
            return list
        except Exception as err:
            logging.info(
                "Unable to get instances by tag name: " + str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout))
            append_result(str({"error": "Unable to get instances",
                               "error_message": str(err) + "\n Traceback: " + traceback.print_exc(
                                   file=sys.stdout)}))
            traceback.print_exc(file=sys.stdout)

    def get_datalake(self, resource_group_name, datalake_name):
        try:
            result = self.datalake_client.account.get(
                resource_group_name,
                datalake_name
            )
            return result
        except AzureExceptions.CloudError as err:
            if err.status_code == 404:
                return ''
        except Exception as err:
            logging.info(
                "Unable to get Data Lake account: " + str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout))
            append_result(str({"error": "Unable to get Data Lake account",
                               "error_message": str(err) + "\n Traceback: " + traceback.print_exc(
                                   file=sys.stdout)}))
            traceback.print_exc(file=sys.stdout)

    def list_datalakes(self, resource_group_name):
        try:
            result = self.datalake_client.account.list_by_resource_group(resource_group_name)
            return result
        except AzureExceptions.CloudError as err:
            if err.status_code == 404:
                return ''
        except Exception as err:
            logging.info(
                "Unable to list Data Lake accounts: " + str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout))
            append_result(str({"error": "Unable to list Data Lake accounts",
                               "error_message": str(err) + "\n Traceback: " + traceback.print_exc(
                                   file=sys.stdout)}))
            traceback.print_exc(file=sys.stdout)

    def verify_datalake_directory(self, datalake_name, dir_name):
        try:
            datalake_client = core.AzureDLFileSystem(self.dl_filesystem_creds, store_name=datalake_name)
            result = datalake_client.exists(dir_name)
            return result
        except Exception as err:
            logging.info(
                "Unable to verify Data Lake directory: " + str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout))
            append_result(str({"error": "Unable to verify Data Lake directory",
                               "error_message": str(err) + "\n Traceback: " + traceback.print_exc(
                                   file=sys.stdout)}))
            traceback.print_exc(file=sys.stdout)

    def get_storage_account(self, resource_group_name, account_name):
        try:
            result = self.storage_client.storage_accounts.get_properties(
                resource_group_name,
                account_name
            )
            return result
        except AzureExceptions.CloudError as err:
            if err.status_code == 404:
                return ''
        except Exception as err:
            logging.info(
                "Unable to get Storage account: " + str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout))
            append_result(str({"error": "Unable to get Storage account",
                               "error_message": str(err) + "\n Traceback: " + traceback.print_exc(
                                   file=sys.stdout)}))
            traceback.print_exc(file=sys.stdout)

    def list_storage_accounts(self, resource_group_name):
        try:
            result = self.storage_client.storage_accounts.list_by_resource_group(resource_group_name)
            return result
        except AzureExceptions.CloudError as err:
            if err.status_code == 404:
                return ''
        except Exception as err:
            logging.info(
                "Unable to list storage accounts: " + str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout))
            append_result(str({"error": "Unable to list Data Lake accounts",
                               "error_message": str(err) + "\n Traceback: " + traceback.print_exc(
                                   file=sys.stdout)}))
            traceback.print_exc(file=sys.stdout)

    def check_account_availability(self, account_name):
        try:
            result = self.storage_client.storage_accounts.check_name_availability(account_name)
            return result
        except Exception as err:
            logging.info(
                "Unable to check Storage account name availability: " + str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout))
            append_result(str({"error": "Unable to check Storage account name availability",
                               "error_message": str(err) + "\n Traceback: " + traceback.print_exc(
                                   file=sys.stdout)}))
            traceback.print_exc(file=sys.stdout)

    def list_storage_keys(self, resource_group_name, account_name):
        try:
            result = []
            get_keys = self.storage_client.storage_accounts.list_keys(resource_group_name, account_name).keys
            for key in get_keys:
                result.append(key.value)
            return result
        except Exception as err:
            logging.info(
                "Unable to list storage account keys: " + str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout))
            append_result(str({"error": "Unable to list storage account keys",
                               "error_message": str(err) + "\n Traceback: " + traceback.print_exc(
                                   file=sys.stdout)}))
            traceback.print_exc(file=sys.stdout)

    def list_container_content(self, resource_group_name, account_name, container_name):
        try:
            result = []
            secret_key = list_storage_keys(resource_group_name, account_name)[0]
            block_blob_service = BlockBlobService(account_name=account_name, account_key=secret_key)
            content = block_blob_service.list_blobs(container_name)
            for blob in content:
                result.append(blob.name)
            return result
        except Exception as err:
            logging.info(
                "Unable to list container content: " + str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout))
            append_result(str({"error": "Unable to list container content",
                               "error_message": str(err) + "\n Traceback: " + traceback.print_exc(
                                   file=sys.stdout)}))
            traceback.print_exc(file=sys.stdout)

    def get_static_ip(self, resource_group_name, ip_name):
        try:
            result = self.network_client.public_ip_addresses.get(
                resource_group_name,
                ip_name
            )
            return result
        except AzureExceptions.CloudError as err:
            if err.status_code == 404:
                return ''
        except Exception as err:
            logging.info(
                "Unable to get static IP address: " + str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout))
            append_result(str({"error": "Unable to get static IP address",
                               "error_message": str(err) + "\n Traceback: " + traceback.print_exc(
                                   file=sys.stdout)}))
            traceback.print_exc(file=sys.stdout)

    def list_static_ips(self, resource_group_name):
        try:
            result = self.network_client.public_ip_addresses.list(resource_group_name)
            return result
        except AzureExceptions.CloudError as err:
            if err.status_code == 404:
                return ''
        except Exception as err:
            logging.info(
                "Unable to list static IP addresses: " + str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout))
            append_result(str({"error": "Unable to list static IP addresses",
                               "error_message": str(err) + "\n Traceback: " + traceback.print_exc(
                                   file=sys.stdout)}))
            traceback.print_exc(file=sys.stdout)

    def check_free_ip(self, resource_group_name, vpc_name, ip_address):
        try:
            result = self.network_client.virtual_networks.check_ip_address_availability(
                resource_group_name,
                vpc_name,
                ip_address
            )
            if not result.available:
                return self.check_free_ip(resource_group_name, vpc_name, result.available_ip_addresses[0])
            if result.available:
                return ip_address
        except Exception as err:
            logging.info(
                "Unable to check private ip: " + str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout))
            append_result(str({"error": "Unable to check private ip",
                               "error_message": str(err) + "\n Traceback: " + traceback.print_exc(
                                   file=sys.stdout)}))
            traceback.print_exc(file=sys.stdout)

    def get_instance_public_ip_address(self, resource_group_name, instance_name):
        try:
            instance = self.compute_client.virtual_machines.get(resource_group_name, instance_name)
            for i in instance.network_profile.network_interfaces:
                network_interface = self.network_client.network_interfaces.get(resource_group_name, i.id.split('/')[-1])
                for j in network_interface.ip_configurations:
                    public_ip_address = self.network_client.public_ip_addresses.get(resource_group_name,
                                                                          j.public_ip_address.id.split('/')[-1])
                    return public_ip_address.ip_address
        except Exception as err:
            logging.info(
                "Unable to get instance public IP address: " + str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout))
            append_result(str({"error": "Unable to get instance public IP address",
                               "error_message": str(err) + "\n Traceback: " + traceback.print_exc(
                                   file=sys.stdout)}))
            traceback.print_exc(file=sys.stdout)

    def get_private_ip_address(self, resource_group_name, instance_name):
        try:
            instance = self.compute_client.virtual_machines.get(resource_group_name, instance_name)
            for i in instance.network_profile.network_interfaces:
                network_interface = self.network_client.network_interfaces.get(resource_group_name, i.id.split('/')[-1])
                for j in network_interface.ip_configurations:
                    return j.private_ip_address
        except Exception as err:
            logging.info(
                "Unable to get instance private IP address: " + str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout))
            append_result(str({"error": "Unable to get instance private IP address",
                               "error_message": str(err) + "\n Traceback: " + traceback.print_exc(
                                   file=sys.stdout)}))
            traceback.print_exc(file=sys.stdout)

    def get_network_interface(self, resource_group_name, network_interface_name):
        try:
            result = self.network_client.network_interfaces.get(resource_group_name, network_interface_name)
            return result
        except AzureExceptions.CloudError as err:
            if err.status_code == 404:
                return ''
        except Exception as err:
            logging.info(
                "Unable to get Network interface: " + str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout))
            append_result(str({"error": "Unable to get Network interface",
                               "error_message": str(err) + "\n Traceback: " + traceback.print_exc(
                                   file=sys.stdout)}))
            traceback.print_exc(file=sys.stdout)

    def list_network_interfaces(self, resource_group_name):
        try:
            result = self.network_client.network_interfaces.list(resource_group_name)
            return result
        except AzureExceptions.CloudError as err:
            if err.status_code == 404:
                return ''
        except Exception as err:
            logging.info(
                "Unable to list Network interfaces: " + str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout))
            append_result(str({"error": "Unable list Network interfaces",
                               "error_message": str(err) + "\n Traceback: " + traceback.print_exc(
                                   file=sys.stdout)}))
            traceback.print_exc(file=sys.stdout)

    def get_network_peering_status(self, resource_group_name,
                                   virtual_network_name,
                                   virtual_network_peering_name):
        try:
            result = self.network_client.virtual_network_peerings.get(resource_group_name,
                                                                        virtual_network_name,
                                                                        virtual_network_peering_name)
            return result.peering_state
        except Exception as err:
            logging.info(
                "Unable to get peering status: " + str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout))
            append_result(str({"error": "Unable to get peering status", "error_message": str(
                err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout)}))
            traceback.print_exc(file=sys.stdout)

    def get_disk(self, resource_group_name, disk_name):
        try:
            result = self.compute_client.disks.get(resource_group_name, disk_name)
            return result
        except AzureExceptions.CloudError as err:
            if err.status_code == 404:
                return ''
        except Exception as err:
            logging.info(
                "Unable to get instance Disk: " + str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout))
            append_result(str({"error": "Unable to get instance Disk",
                               "error_message": str(err) + "\n Traceback: " + traceback.print_exc(
                                   file=sys.stdout)}))
            traceback.print_exc(file=sys.stdout)

    def list_disks(self, resource_group_name):
        try:
            result = self.compute_client.disks.list_by_resource_group(resource_group_name)
            return result
        except AzureExceptions.CloudError as err:
            if err.status_code == 404:
                return ''
        except Exception as err:
            logging.info(
                "Unable to list instance Disks: " + str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout))
            append_result(str({"error": "Unable to list instance Disks",
                               "error_message": str(err) + "\n Traceback: " + traceback.print_exc(
                                   file=sys.stdout)}))
            traceback.print_exc(file=sys.stdout)

    def get_list_instance_statuses(self, resource_group_name, instance_name_list):
        data = []
        for instance_name in instance_name_list:
            instance_name = instance_name['id']
            host = {}
            try:
                request = self.compute_client.virtual_machines.get(resource_group_name, instance_name,
                                                                   expand='instanceView')
                host['id'] = instance_name
                try:
                    host['status'] = request.instance_view.statuses[1].display_status.split(' ')[1].replace("deallocat",
                                                                                                            "stopp")
                    data.append(host)
                except:
                    host['status'] = request.instance_view.statuses[0].display_status.lower()
                    data.append(host)
            except:
                host['id'] = instance_name
                host['status'] = 'terminated'
                data.append(host)
        return data

    def get_instance_status(self, resource_group_name, instance_name):
        try:
            request = self.compute_client.virtual_machines.get(resource_group_name, instance_name, expand='instanceView')
            try:
                status = request.instance_view.statuses[1].display_status.split(' ')[1].replace("deallocat", "stopp")
            except:
                status = request.instance_view.statuses[0].display_status.lower()
        except:
            status = 'terminated'
        return status

    def get_application(self, application_object_id):
        try:
            result = graphrbac_client.applications.get(application_object_id)
            return result
        except Exception as err:
            logging.info(
                "Unable to get application: " + str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout))
            append_result(str({"error": "Unable to get application",
                               "error_message": str(err) + "\n Traceback: " + traceback.print_exc(
                                   file=sys.stdout)}))
            traceback.print_exc(file=sys.stdout)

    def get_image(self, resource_group_name, image_name):
        try:
            return self.compute_client.images.get(resource_group_name, image_name)
        except AzureExceptions.CloudError as err:
            if err.status_code == 404:
                return ''
        except Exception as err:
            logging.info(
                "Unable to get image: " + str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout))
            append_result(str({"error": "Unable to get image",
                               "error_message": str(err) + "\n Traceback: " + traceback.print_exc(
                                   file=sys.stdout)}))
            traceback.print_exc(file=sys.stdout)

    def get_instance_image(self, resource_group_name, instance_name):
        try:
            instance = self.compute_client.virtual_machines.get(
                resource_group_name, instance_name)
            image = instance.storage_profile.image_reference
            if image.id == None:
                return ('default')
            image = image.id.split("/")
            image = image[-1]
            return (image)
        except Exception as err:
            logging.info(
                "Unable to get instance image: " + str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout))
            append_result(str({"error": "Unable to get instance image",
                               "error_message": str(err) + "\n Traceback: " + traceback.print_exc(
                                   file=sys.stdout)}))
            traceback.print_exc(file=sys.stdout)

    def list_images(self):
        try:
            return self.compute_client.images.list()
        except Exception as err:
            logging.info(
                "Unable to get list images: " + str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout))
            append_result(str({"error": "Unable to get list images",
                               "error_message": str(err) + "\n Traceback: " + traceback.print_exc(
                                   file=sys.stdout)}))
            traceback.print_exc(file=sys.stdout)

    def get_list_private_ip_by_conf_type_and_id(self, conf_type, instance_id):
        try:
            private_list_ip = []
            if conf_type == 'edge_node' or conf_type == 'exploratory':
                private_list_ip.append(AzureMeta().get_private_ip_address(os.environ['conf_service_base_name'], instance_id))
            elif conf_type == 'computational_resource':
                instance_list = AzureMeta().get_instances_name_by_tag(os.environ['conf_service_base_name'], 'Name', instance_id)
                for instance in instance_list:
                    private_list_ip.append(AzureMeta().get_private_ip_address(
                        os.environ['conf_service_base_name'], instance))
            return private_list_ip
        except Exception as err:
            logging.info(
                "Error getting private ip by conf_type and id: " + str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout))
            append_result(str({"error": "Error getting private ip by conf_type and id",
                               "error_message": str(err) + "\n Traceback: " + traceback.print_exc(
                                   file=sys.stdout)}))
            traceback.print_exc(file=sys.stdout)

    def get_vm_disks(self, resource_group_name, instance_name):
        try:
            disk_list = []
            virtual_machine = self.compute_client.virtual_machines.get(resource_group_name,
                                                                       instance_name)
            os_disk_name = virtual_machine.storage_profile.os_disk.name
            os_disk = self.compute_client.disks.get(resource_group_name, os_disk_name)
            disk_list.append(os_disk)
            data_disks = virtual_machine.storage_profile.data_disks
            for disk in data_disks:
                data_disk = self.compute_client.disks.get(resource_group_name, disk.name)
                disk_list.append(data_disk)
            return disk_list
        except Exception as err:
            logging.info(
                "Unable to get disk list: " + str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout))
            append_result(str({"error": "Unable to get disk list",
                               "error_message": str(err) + "\n Traceback: " + traceback.print_exc(
                                   file=sys.stdout)}))
            traceback.print_exc(file=sys.stdout)


def get_instance_private_ip_address(tag_name, instance_name):
    try:
        resource_group_name = os.environ['azure_resource_group_name']
        return AzureMeta().get_private_ip_address(resource_group_name, instance_name)
    except Exception as err:
            logging.info("Error with getting private ip address by name: " + str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout))
            append_result(str({"error": "Error with getting private ip address by name",
                       "error_message": str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout)}))
            traceback.print_exc(file=sys.stdout)
            return ''


def node_count(cluster_name):
    try:
        node_list = []
        resource_group_name = os.environ['azure_resource_group_name']
        for node in AzureMeta().compute_client.virtual_machines.list(resource_group_name):
            if "Name" in node.tags:
                if cluster_name == node.tags["Name"]:
                    node_list.append(node.name)
        result = len(node_list)
        return result
    except Exception as err:
        logging.info("Error with counting nodes in cluster: " + str(err) + "\n Traceback: " + traceback.print_exc(
            file=sys.stdout))
        append_result(str({"error": "Error with counting nodes in cluster",
                           "error_message": str(err) + "\n Traceback: " + traceback.print_exc(file=sys.stdout)}))
        traceback.print_exc(file=sys.stdout)