Class: Fog::Storage::AzureRM::Real

Inherits:
Object
  • Object
show all
Defined in:
lib/fog/azurerm/storage.rb,
lib/fog/azurerm/requests/storage/delete_disk.rb,
lib/fog/azurerm/requests/storage/list_containers.rb,
lib/fog/azurerm/requests/storage/create_container.rb,
lib/fog/azurerm/requests/storage/delete_container.rb,
lib/fog/azurerm/requests/storage/get_blob_metadata.rb,
lib/fog/azurerm/requests/storage/set_blob_metadata.rb,
lib/fog/azurerm/requests/storage/list_storage_accounts.rb,
lib/fog/azurerm/requests/storage/create_storage_account.rb,
lib/fog/azurerm/requests/storage/delete_storage_account.rb,
lib/fog/azurerm/requests/storage/get_container_metadata.rb,
lib/fog/azurerm/requests/storage/set_container_metadata.rb,
lib/fog/azurerm/requests/storage/get_storage_access_keys.rb,
lib/fog/azurerm/requests/storage/get_container_properties.rb,
lib/fog/azurerm/requests/storage/list_storage_account_for_rg.rb,
lib/fog/azurerm/requests/storage/get_container_access_control_list.rb,
lib/fog/azurerm/requests/storage/check_storage_account_name_availability.rb

Overview

This class provides the actual implemention for service calls.

Instance Method Summary collapse

Constructor Details

#initialize(options) ⇒ Real

Returns a new instance of Real.



59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
 
# File 'lib/fog/azurerm/storage.rb', line 59

def initialize(options)
  begin
    require 'azure_mgmt_storage'
    require 'azure/storage'
    @debug = ENV['DEBUG'] || options[:debug]
    require 'azure/core/http/debug_filter' if @debug
  rescue LoadError => e
    retry if require('rubygems')
    raise e.message
  end

  credentials = Fog::Credentials::AzureRM.get_credentials(options[:tenant_id], options[:client_id], options[:client_secret])
  unless credentials.nil?
    @storage_mgmt_client = ::Azure::ARM::Storage::StorageManagementClient.new(credentials)
    @storage_mgmt_client.subscription_id = options[:subscription_id]
  end

  if Fog::Credentials::AzureRM. options
    Azure::Storage.setup(storage_account_name: options[:azure_storage_account_name],
                         storage_access_key: options[:azure_storage_access_key],
                         storage_connection_string: options[:azure_storage_connection_string])

    @blob_client = Azure::Storage::Blob::BlobService.new
    @blob_client.with_filter(Azure::Storage::Core::Filter::ExponentialRetryPolicyFilter.new)
    @blob_client.with_filter(Azure::Core::Http::DebugFilter.new) if @debug
  end
end

Instance Method Details

#check_storage_account_name_availability(params) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
# File 'lib/fog/azurerm/requests/storage/check_storage_account_name_availability.rb', line 6

def (params)
  Fog::Logger.debug "Checking Name availability: #{params.name}."
  begin
    promise = @storage_mgmt_client.storage_accounts.check_name_availability(params)
    result = promise.value!
    name_available_obj = Azure::ARM::Storage::Models::CheckNameAvailabilityResult.serialize_object(result.body)
    if name_available_obj['nameAvailable'] == true
      Fog::Logger.debug "Name: #{params.name} is available."
      true
    else
      Fog::Logger.debug "Name: #{params.name} is not available."
      Fog::Logger.debug "Reason: #{name_available_obj['reason']}."
      false
    end
  rescue MsRestAzure::AzureOperationError => e
    msg = "Exception checking name availability: #{e.body['error']['message']}"
    raise msg if e.body['error']['code'] == 'ResourceGroupNotFound'
  end
end

#create_container(name, options = {}) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
 
# File 'lib/fog/azurerm/requests/storage/create_container.rb', line 6

def create_container(name, options = {})
  Fog::Logger.debug "Creating container: #{name}."
  begin
    container = @blob_client.create_container(name, options)
    Fog::Logger.debug "Container #{name} created successfully."
    container
  rescue Azure::Core::Http::HTTPError => ex
    raise "Exception in creating the container #{name}: #{ex.inspect}"
  end
end

#create_storage_account(resource_group, name, params) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
# File 'lib/fog/azurerm/requests/storage/create_storage_account.rb', line 6

def (resource_group, name, params)
  Fog::Logger.debug "Creating Storage Account: #{name}."
  begin
    promise = @storage_mgmt_client.storage_accounts.create(resource_group, name, params)
    response = promise.value!
    Fog::Logger.debug 'Storage Account created successfully.'
    body = response.body
    body.properties.last_geo_failover_time = DateTime.parse(Time.now.to_s)
    body.properties.creation_time = DateTime.parse(Time.now.to_s)
    result = Azure::ARM::Storage::Models::StorageAccount.serialize_object(response.body)
    result
  rescue MsRestAzure::AzureOperationError => e
    msg = "Exception creating Storage Account #{name} in Resource Group #{resource_group}. #{e.body['error']['message']}"
    raise msg
  end
end

#delete_container(name, options = {}) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
 
# File 'lib/fog/azurerm/requests/storage/delete_container.rb', line 6

def delete_container(name, options = {})
  Fog::Logger.debug "Deleting container: #{name}."
  begin
    @blob_client.delete_container(name, options)
    Fog::Logger.debug "Container #{name} deleted successfully."
    true
  rescue Azure::Core::Http::HTTPError => ex
    raise "Exception in deleting the container #{name}: #{ex.inspect}"
  end
end

#delete_disk(resource_group, storage_account_name, blob_name) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
# File 'lib/fog/azurerm/requests/storage/delete_disk.rb', line 6

def delete_disk(resource_group, , blob_name)
  Fog::Logger.debug "Deleting Disk: #{blob_name}."
  access_key = get_storage_access_keys(resource_group, )['key2']
  client = Azure::Storage::Client.new(storage_account_name: , storage_access_key: access_key)
  blob_service = Azure::Storage::Blob::BlobService.new(client: client)
  begin
    result = blob_service.delete_blob('vhds', "#{blob_name}.vhd")
    if result.nil?
      Fog::Logger.debug "Successfully deleted Disk: #{blob_name}."
      true
    else
      Fog::Logger.debug 'Error deleting Disk.'
      false
    end
  rescue Azure::Core::Http::HTTPError => e
    msg = "Error deleting Disk. #{e.description}"
    raise msg
  end
end

#delete_storage_account(resource_group, name) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
 
# File 'lib/fog/azurerm/requests/storage/delete_storage_account.rb', line 6

def (resource_group, name)
  Fog::Logger.debug "Deleting Storage Account: #{name}."
  begin
    promise = @storage_mgmt_client.storage_accounts.delete(resource_group, name)
    promise.value!
    Fog::Logger.debug "Storage Account #{name} deleted successfully."
    true
  rescue  MsRestAzure::AzureOperationError => e
    msg = "Exception deleting Storage Account #{name} in Resource Group #{resource_group}. #{e.body['error']['message']}"
    raise msg
  end
end

#get_blob_metadata(container_name, name) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
 
# File 'lib/fog/azurerm/requests/storage/get_blob_metadata.rb', line 6

def get_blob_metadata(container_name, name)
  Fog::Logger.debug "Get Blob #{name} metadata in container #{container_name}."
  begin
      blob = @blob_client.get_blob_metadata(container_name, name)
      Fog::Logger.debug "Getting metadata of blob #{name} successfully."
      blob.metadata
    rescue Azure::Core::Http::HTTPError => ex
      raise "Exception in getting metadata of Blob #{name}: #{ex.inspect}"
    end
end

#get_container_access_control_list(name, options = {}) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
 
# File 'lib/fog/azurerm/requests/storage/get_container_access_control_list.rb', line 6

def get_container_access_control_list(name, options = {})
  Fog::Logger.debug "Get container ACL: #{name}."
  begin
    container_acl = @blob_client.get_container_acl(name, options)
    Fog::Logger.debug "Getting ACL of container #{name} successfully."
    container_acl
  rescue Azure::Core::Http::HTTPError => ex
    raise "Exception in getting ACL of container #{name}: #{ex.inspect}"
  end
end

#get_container_metadata(name) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
 
# File 'lib/fog/azurerm/requests/storage/get_container_metadata.rb', line 6

def get_container_metadata(name)
  Fog::Logger.debug "Get Container #{name} metadata."
  begin
    container = @blob_client.get_container_metadata(name)
    Fog::Logger.debug "Getting metadata of container #{name} successfully."
    container.metadata
  rescue Azure::Core::Http::HTTPError => ex
    raise "Exception in getting metadata of Container #{name}: #{ex.inspect}"
  end
end

#get_container_properties(name, options = {}) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
 
# File 'lib/fog/azurerm/requests/storage/get_container_properties.rb', line 6

def get_container_properties(name, options = {})
  Fog::Logger.debug "Get container properties: #{name}."
  begin
    container_properties = @blob_client.get_container_properties(name, options)
    Fog::Logger.debug "Getting properties of container #{name} successfully."
    container_properties
  rescue Azure::Core::Http::HTTPError => ex
    raise "Exception in getting properties of container #{name}: #{ex.inspect}"
  end
end

#get_storage_access_keys(resource_group, storage_account_name, options = {}) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
 
# File 'lib/fog/azurerm/requests/storage/get_storage_access_keys.rb', line 6

def get_storage_access_keys(resource_group, , options = {})
  Fog::Logger.debug "Getting storage access keys for storage account: #{}."
  begin
     = @storage_mgmt_client.storage_accounts.list_keys(resource_group, , options).value!
    Fog::Logger.debug "Storage access keys for storage account: #{} listed successfully."
    Azure::ARM::Storage::Models::StorageAccountKeys.serialize_object(.body)
  rescue MsRestAzure::AzureOperationError => e
    msg = "Error getting storage access keys. #{e.body['error']['message']}"
    raise msg
  end
end

#list_containers(options = {}) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
 
# File 'lib/fog/azurerm/requests/storage/list_containers.rb', line 6

def list_containers(options = {})
  Fog::Logger.debug "Listing containers."
  begin
    containers = @blob_client.list_containers(options)
    Fog::Logger.debug 'Listing containers successfully.'
    containers
  rescue Azure::Core::Http::HTTPError => ex
    raise "Exception in listing containers: #{ex.inspect}"
  end
end

#list_storage_account_for_rg(resource_group) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
# File 'lib/fog/azurerm/requests/storage/list_storage_account_for_rg.rb', line 6

def (resource_group)
  begin
    promise = @storage_mgmt_client.storage_accounts.list_by_resource_group(resource_group)
    response = promise.value!
    body = response.body.value
    body.each do |obj|
      obj.properties.last_geo_failover_time = DateTime.parse(Time.now.to_s)
    end
    result = Azure::ARM::Storage::Models::StorageAccountListResult.serialize_object(response.body)['value']
    result
  rescue  MsRestAzure::AzureOperationError => e
    msg = "Exception listing Storage Accounts in Resource Group #{resource_group}. #{e.body['error']['message']}"
    raise msg
  end
end

#list_storage_accounts ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
# File 'lib/fog/azurerm/requests/storage/list_storage_accounts.rb', line 6

def list_storage_accounts
  begin
    promise = @storage_mgmt_client.storage_accounts.list
    response = promise.value!
    body = response.body.value
    body.each do |obj|
      obj.properties.last_geo_failover_time = DateTime.parse(Time.now.to_s)
    end
    result = Azure::ARM::Storage::Models::StorageAccountListResult.serialize_object(response.body)['value']
    puts "Result: #{result}"
    result
  rescue  MsRestAzure::AzureOperationError => e
    msg = "Exception listing Storage Accounts. #{e.body['error']['message']}"
    raise msg
  end
end

#set_blob_metadata(container_name, name, metadata) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
 
# File 'lib/fog/azurerm/requests/storage/set_blob_metadata.rb', line 6

def set_blob_metadata(container_name, name, metadata)
  Fog::Logger.debug "Set Blob #{name} metadata in a container #{container_name}."
  begin
    @blob_client.set_blob_metadata(container_name, name, metadata)
    Fog::Logger.debug "Setting metadata of blob #{name} successfully."
    true
  rescue Azure::Core::Http::HTTPError => ex
    raise "Exception in setting metadata of Blob #{name}: #{ex.inspect}"
  end
end

#set_container_metadata(name, metadata) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
 
# File 'lib/fog/azurerm/requests/storage/set_container_metadata.rb', line 6

def set_container_metadata(name, metadata)
  Fog::Logger.debug "Set Container #{name} metadata."
  begin
    @blob_client.set_container_metadata(name, metadata)
    Fog::Logger.debug "Setting metadata of container #{name} successfully."
    true
  rescue Azure::Core::Http::HTTPError => ex
    raise "Exception in setting metadata of Container #{name}: #{ex.inspect}"
  end
end