Class: Azure::Armrest::StorageAccountService

Inherits:
ResourceGroupBasedService show all
Defined in:
lib/azure/armrest/storage_account_service.rb

Overview

Class for managing storage accounts.

Constant Summary

Constants inherited from ResourceGroupBasedService

ResourceGroupBasedService::SERVICE_NAME_MAP

Instance Attribute Summary

Attributes inherited from ArmrestService

#api_version, #armrest_configuration, #base_url, #provider, #service_name

Instance Method Summary collapse

Methods inherited from ResourceGroupBasedService

#delete, #delete_by_id, #get_by_id

Methods inherited from ArmrestService

configure, #get_provider, #get_subscription, #list_locations, #list_resource_groups, #list_resources, #list_subscriptions, #locations, #poll, #tags, #tenants, #wait

Constructor Details

#initialize(configuration, options = {}) ⇒ StorageAccountService

Creates and returns a new StorageAccountService (SAS) instance.



9
10
11
 
# File 'lib/azure/armrest/storage_account_service.rb', line 9

def initialize(configuration, options = {})
  super(configuration, 'storageAccounts', 'Microsoft.Storage', options)
end

Instance Method Details

#accounts_by_name ⇒ Object 



245
246
247
 
# File 'lib/azure/armrest/storage_account_service.rb', line 245

def accounts_by_name
  @accounts_by_name ||= list_all.each_with_object({}) { |sa, sah| sah[sa.name] = sa }
end

#create(account_name, rgroup = configuration.resource_group, options) ⇒ Object

Creates a new storage account, or updates an existing account with the specified parameters.

Note that the name of the storage account within the specified must be 3-24 alphanumeric lowercase characters. This name must be unique across all subscriptions.

The options available are as follows:

  • :validating Optional. Set to 'nameAvailability' to indicate that the account name must be checked for global availability.

  • :properties

    • :accountType The type of storage account, e.g. “Standard_GRS”.

  • :location Required: One of the Azure geo regions, e.g. 'West US'.

  • :tags A hash of tags to describe the resource. You may have a maximum of 10 tags, and each key has a max size of 128 characters, and each value has a max size of 256 characters. These are optional.

Example:

sas = Azure::Armrest::StorageAccountService(config)

options = {
  :location => "Central US",
  :tags     => {:redhat => true},
  :sku      => {:name => "Standard_LRS"},
  :kind     => "Storage"
}

sas.create("your_storage_account", "your_resource_group", options)



96
97
98
99
100
101
102
103
104
105
106
107
 
# File 'lib/azure/armrest/storage_account_service.rb', line 96

def create(, rgroup = configuration.resource_group, options)
  validating = options.delete(:validating)
  ()

  acct = super(, rgroup, options) do |url|
    url << "&validating=" << validating if validating
  end

  acct.configuration = configuration

  acct
end

#get(name, resource_group = configuration.resource_group) ⇒ Object

Same as other resource based get methods, but also sets the proxy on the model object.



15
16
17
 
# File 'lib/azure/armrest/storage_account_service.rb', line 15

def get(name, resource_group = configuration.resource_group)
  super.tap { |model| model.configuration = configuration }
end

#get_from_url(url, resource_group = configuration.resource_group) ⇒ Object

Retrieve information about the storage account using a URI. You may optionally specify a resource group name, which will slightly faster. By default it will use the resource group specified in the service configuration, if any.

Example:

sas = Azure::Armrest::StorageAccountService.new(<config>)
url = https://foo.blob.core.windows.net/vhds/dberger1201691213010.vhd"

sas.get_from_url(url)
sas.get_from_url(url, some_resource_group)



43
44
45
46
47
48
49
50
51
52
53
54
55
56
 
# File 'lib/azure/armrest/storage_account_service.rb', line 43

def get_from_url(url, resource_group = configuration.resource_group)
  uri  = Addressable::URI.parse(url)
  name = uri.host.split('.').first

  unless resource_group
    rservice = Azure::Armrest::ResourceService.new(configuration)
    filter   = "resourceType eq 'Microsoft.Storage/storageAccounts' and name eq '#{name}'"
    resource = rservice.list_all(:filter => filter, :all => true).first
    raise ArgumentError, "unable to find resource group for #{url}" unless resource
    resource_group = resource.id[/resourceGroups\/(.*?)\//i, 1]
  end

  get(name, resource_group)
end

#get_from_vm(vm) ⇒ Object

Return the storage account for the virtual machine model vm. Note that this method returns the storage account for the OS disk.



224
225
226
 
# File 'lib/azure/armrest/storage_account_service.rb', line 224

def get_from_vm(vm)
  get_from_url(vm.properties.storage_profile.os_disk.vhd.uri)
end

#get_os_disk(vm) ⇒ Object

Get information for the underlying VHD file based on the properties of the virtual machine model vm.



231
232
233
234
235
236
237
238
239
240
241
242
243
 
# File 'lib/azure/armrest/storage_account_service.rb', line 231

def get_os_disk(vm)
  uri = Addressable::URI.parse(vm.properties.storage_profile.os_disk.vhd.uri)

  # The uri looks like https://foo123.blob.core.windows.net/vhds/something123.vhd
  disk = File.basename(uri.to_s)       # disk name, e.g. 'something123.vhd'
  path = File.dirname(uri.path)[1..-1] # container, e.g. 'vhds'

  acct = get_from_vm(vm)
  keys = (acct.name, acct.resource_group)
  key  = keys['key1'] || keys['key2']

  acct.blob_properties(path, disk, key)
end

#list(resource_group = configuration.resource_group, skip_accessors_definition = false) ⇒ Object

Same as other resource based list methods, but also sets the proxy on each model object.



21
22
23
 
# File 'lib/azure/armrest/storage_account_service.rb', line 21

def list(resource_group = configuration.resource_group, skip_accessors_definition = false)
  super.each { |model| model.configuration = configuration }
end

#list_account_key_objects(account_name, group = configuration.resource_group, skip_accessors_definition = false) ⇒ Object Also known as: list_storage_account_key_objects

Returns a list of StorageAccountKey objects consisting of information the primary and secondary keys. This method requires an api-version string of 2016-01-01 or later, or an error is raised.

If you want a plain hash, use the list_account_keys method instead.



134
135
136
137
138
139
140
141
142
143
144
 
# File 'lib/azure/armrest/storage_account_service.rb', line 134

def (, group = configuration.resource_group, skip_accessors_definition = false)
  validate_resource_group(group)

  unless recent_api_version?
    raise ArgumentError, "unsupported api-version string '#{api_version}'"
  end

  url = build_url(group, , 'listKeys')
  response = rest_post(url)
  JSON.parse(response.body)['keys'].map { |hash| StorageAccountKey.new(hash, skip_accessors_definition) }
end

#list_account_keys(account_name, group = configuration.resource_group) ⇒ Object Also known as: list_storage_account_keys

Returns the primary and secondary access keys for the given storage account. This method will return a hash with 'key1' and 'key2' as its keys.

If you want a list of StorageAccountKey objects, then use the list_account_key_objects method instead.



116
117
118
119
120
121
122
123
124
 
# File 'lib/azure/armrest/storage_account_service.rb', line 116

def (, group = configuration.resource_group)
  validate_resource_group(group)

  url = build_url(group, , 'listKeys')
  response = rest_post(url)
  hash = JSON.parse(response.body)

  (hash)
end

#list_all(filter = {}) ⇒ Object

Same as other resource based list_all methods, but also sets the proxy on each model object.



27
28
29
 
# File 'lib/azure/armrest/storage_account_service.rb', line 27

def list_all(filter = {})
  super(filter).each { |model| model.configuration = configuration }
end

#list_all_private_images(filter = {}) ⇒ Object

Returns a list of PrivateImage objects that are available for provisioning for all storage accounts in the current subscription.

You may optionally reduce the set of storage accounts that will be scanned by providing a filter, where the keys are StorageAccount properties.

Example:

sas.list_all_private_images(:location => 'eastus', resource_group => 'some_group')

Note that for string values the comparison is caseless.



201
202
203
204
 
# File 'lib/azure/armrest/storage_account_service.rb', line 201

def list_all_private_images(filter = {})
  storage_accounts = list_all(filter.merge(:skip_accessors_definition => true))
  get_private_images(storage_accounts)
end

#list_private_images(group = configuration.resource_group) ⇒ Object

Returns a list of PrivateImage objects that are available for provisioning for all storage accounts in the provided resource group.

The custom keys :uri and :operating_system have been added to the resulting PrivateImage objects for convenience.

Example:

sas.list_private_images(your_resource_group)



216
217
218
219
 
# File 'lib/azure/armrest/storage_account_service.rb', line 216

def list_private_images(group = configuration.resource_group)
  storage_accounts = list(group, true)
  get_private_images(storage_accounts)
end

#parse_uri(uri) ⇒ Object 



249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
 
# File 'lib/azure/armrest/storage_account_service.rb', line 249

def parse_uri(uri)
  uri = Addressable::URI.parse(uri)
  host_components = uri.host.split('.')

  rh = {
    :scheme        => uri.scheme,
    :account_name  => host_components[0],
    :service_name  => host_components[1],
    :resource_path => uri.path
  }

  # TODO: support other service types.
  return rh unless rh[:service_name] == "blob"

  blob_components = uri.path.split('/', 3)
  if blob_components[2]
    rh[:container] = blob_components[1]
    rh[:blob]      = blob_components[2]
  else
    rh[:container] = '$root'
    rh[:blob]      = blob_components[1]
  end

  return rh unless uri.query && uri.query.start_with?("snapshot=")
  rh[:snapshot] = uri.query.split('=', 2)[1]
  rh
end

#regenerate_account_key_objects(account_name, group = configuration.resource_group, key_name = 'key1') ⇒ Object Also known as: regenerate_storage_account_key_objects

Same as regenerate_account_keys, but returns an array of StorageAccountKey objects instead.

This method requires an api-version string of 2016-01-01 or later or an ArgumentError is raised.



172
173
174
175
176
177
178
179
180
181
182
183
184
 
# File 'lib/azure/armrest/storage_account_service.rb', line 172

def (, group = configuration.resource_group, key_name = 'key1')
  validate_resource_group(group)

  unless recent_api_version?
    raise ArgumentError, "unsupported api-version string '#{api_version}'"
  end

  options = {'keyName' => key_name}

  url = build_url(group, , 'regenerateKey')
  response = rest_post(url, options.to_json)
  JSON.parse(response.body)['keys'].map { |hash| StorageAccountKey.new(hash) }
end

#regenerate_account_keys(account_name, group = configuration.resource_group, key_name = 'key1') ⇒ Object Also known as: regenerate_storage_account_keys

Regenerates the primary or secondary access keys for the given storage account. The key_name may be either 'key1' or 'key2'. If no key name is provided, then it defaults to 'key1'.



152
153
154
155
156
157
158
159
160
161
162
 
# File 'lib/azure/armrest/storage_account_service.rb', line 152

def (, group = configuration.resource_group, key_name = 'key1')
  validate_resource_group(group)

  options = {'keyName' => key_name}

  url = build_url(group, , 'regenerateKey')
  response = rest_post(url, options.to_json)
  hash = JSON.parse(response.body)

  (hash)
end