def get_storage_size()

in azure-sdk-calc-storage-size/azure-data.py [0:0]

• 50 lines of code
• 11 McCabe index (conditional complexity)

    def get_storage_size(self, options=None):

        try:

            if options is None:

                options = SizeOptions()

            storage_accounts = self.get_all_storage_accounts()
            count = 0

            for storage_account in storage_accounts:

                storage_account_name = storage_account.name

                if options.account_names is not None and storage_account_name not in options.account_names:

                    print("Skipping storage account: " + storage_account_name , Log_type.debug)
                    continue

                count += 1
                self.log_info("\nProcessing storage account: " + storage_account_name , Log_type.debug)

                total_account_size = 0
                
                resource_group_name = self.get_storage_account_resource_group(storage_account.id)
                account_key = self.get_storage_account_keys(resource_group_name, storage_account_name)['key1']
                blob_containers = self.get_blob_containers_by_storage_account(storage_account_name, account_key)

                for container in blob_containers:

                    container_name = container.name

                    if options.container_names is not None and container_name not in options.container_names:

                        print("Skipping container: " + container_name, Log_type.debug)
                        continue

                    self.log_info("Reading size for container: " +  container_name, Log_type.debug)

                    total_blob_container_size = 0

                    blobs = self.get_all_blobs_by_blob_container_name(storage_account_name,
                        account_key, container_name)

                    for blob in blobs:

                        with BlobClient(
                                account_url=f'{storage_account_name}.blob.core.windows.net',
                                container_name=container.name, blob_name=blob.name,
                                credential=account_key) as blob_client:
                            size = blob_client.get_blob_properties().size

                        total_blob_container_size +=  size
                        total_account_size +=  size

                        
                        if options.log_individual_blobs:
                            
                            blob_size_str = humanfriendly.format_size(size)                        
                            message = "{}, {}, {}, {}".format("blob_size", blob.name, str(size), blob_size_str)
                            self.log_info(message, Log_type.blob_info)

                    # ...for each blob
                    
                    blob_container_size_str = humanfriendly.format_size(total_blob_container_size)
                    message = "{}, {}, {}, {}".format("blob_container_total", container_name,
                                                                            str(total_blob_container_size),
                                                                            blob_container_size_str)
                    self.log_info(message, Log_type.container_info)

                # ...for each container
                
                total_account_size_str = humanfriendly.format_size(total_account_size)

                self.log_info("Number of storage accounts processed: " + str(count), Log_type.debug)

                message = "{}, {}, {}, {}".format("storage_total",storage_account_name, str(total_account_size), total_account_size_str)
                self.log_info(message, Log_type.storage_info)

        except Exception as e:

            print(str(e))
            self.log.log_error(str(e))