azure-armrest 0.0.1 → 0.0.2

data/lib/azure/armrest/availability_set_service.rb

@@ -0,0 +1,100 @@
+# Azure namespace
+module Azure
+  # Armrest namespace
+  module Armrest
+    # Base class for managing availability sets.
+    class AvailabilitySetService < ArmrestService
+      # The provider used in requests when gathering ASM information.
+      attr_reader :provider
+
+      # Create and return a new AvailabilitySetService (ASM) instance.
+      #
+      def initialize(_armrest_configuration, options = {})
+        super
+
+        @provider = options[:provider] || 'Microsoft.Compute'
+
+        set_service_api_version(options, 'availabilitySets')
+      end
+
+      # Creates a new availability set with the given name. The optional +tags+
+      # argument should be a hash, if provided.
+      #
+      def create(name, location, tags = nil, resource_group = armrest_configuration.resource_group)
+        raise ArgumentError, "No resource group specified" if resource_group.nil?
+
+        url = build_url(resource_group, name)
+        body = {:name => name, :location => location, :tags => tags}.to_json
+        response = rest_put(url, body)
+        response.return!
+      end
+
+      alias update create
+
+      # Deletes the +name+ availability set.
+      #
+      def delete(name, resource_group = armrest_configuration.resource_group)
+        raise ArgumentError, "No resource group specified" if resource_group.nil?
+        url = build_url(resource_group, name)
+        response = rest_delete(url)
+        response.return!
+      end
+
+      # Retrieves the options of an availability set +name+.
+      #
+      def get(name, resource_group = armrest_configuration.resource_group)
+        raise ArgumentError, "No resource group specified" if resource_group.nil?
+        url = build_url(resource_group, name)
+        response = rest_get(url)
+        JSON.parse(response.body)
+      end
+
+      # List availability sets.
+      #
+      def list(resource_group = armrest_configuration.resource_group)
+        array = []
+
+        if resource_group
+          url = build_url(resource_group)
+          response = rest_get(url)
+          array << JSON.parse(response.body)['value']
+        else
+          threads = []
+          mutex = Mutex.new
+
+          resource_groups.each do |group|
+            url = build_url(group['name'])
+
+            threads << Thread.new(url) do |thread_url|
+              response = rest_get(thread_url)
+              result = JSON.parse(response)['value']
+              mutex.synchronize{ array << result if result }
+            end
+          end
+
+          threads.each(&:join)
+        end
+
+        array.flatten
+      end
+
+      # Builds a URL based on subscription_id an resource_group and any other
+      # arguments provided, and appends it with the api_version.
+      #
+      def build_url(resource_group, *args)
+        url = File.join(
+          Azure::Armrest::COMMON_URI,
+          armrest_configuration.subscription_id,
+          'resourceGroups',
+          resource_group,
+          'providers',
+          @provider,
+          'availabilitySets',
+        )
+
+        url = File.join(url, *args) unless args.empty?
+        url << "?api-version=#{@api_version}"
+      end
+    end # AvailabilitySetService
+  end # Armrest
+end # Azure

data/lib/azure/armrest/{event_manager.rb → event_service.rb}

@@ -1,12 +1,12 @@
 module Azure
   module Armrest
-    class EventManager < ArmrestManager
+    class EventService < ArmrestService
 
-      def initialize(options = {})
+      def initialize(armrest_configuration, _options = {})
         super
 
         @base_url += "providers/microsoft.insights/eventtypes/management/values"
-        @base_url += "?api-version=#{@api_version}"
+        @base_url += "?api-version=#{armrest_configuration.api_version}"
       end
 
       # check what data type the event channel is

data/lib/azure/armrest/resource_group_service.rb

@@ -0,0 +1,86 @@
+module Azure
+  module Armrest
+    class ResourceGroupService < ArmrestService
+      # The provider used in http requests. The default is 'Microsoft.Resources'
+      attr_reader :provider
+
+      # Creates and returns a new ResourceGroupService object.
+      #
+      def initialize(_armrest_configuration, options = {})
+        super
+        @provider = options[:provider] || 'Microsoft.Resources'
+        set_service_api_version(options, 'resourceGroups')
+      end
+
+      # List all the resources for the current subscription. You can optionally
+      # pass :top or :filter options as well to restrict returned results.
+      #
+      # If you pass a :resource_group option, then only resources for that
+      # resource group are returned.
+      #
+      # Examples:
+      #
+      #   rgs = ResourceGroupService.new
+      #   rgs.list(:top => 2)
+      #   rgs.list(:filter => "location eq 'centralus'")
+      #
+      def list(options = {})
+        url = build_url
+        url << "&$top=#{options[:top]}" if options[:top]
+        url << "&$filter=#{options[:filter]}" if options[:filter]
+
+        response = rest_get(URI.escape(url))
+
+        JSON.parse(response.body)["value"]
+      end
+
+      # Creates a new +group+ in +location+ for the current subscription.
+      # You may optionally apply +tags+.
+      #
+      def create(group, location, tags = nil)
+        body = {:location => location, :tags => tags}.to_json
+        url = build_url(group)
+
+        response = rest_put(url, body)
+
+        JSON.parse(response.body)
+      end
+
+      # Delete a resource group from the current subscription.
+      #
+      def delete(group)
+        url = build_url(group)
+        response = rest_delete(url)
+        response.return!
+      end
+
+      # Returns information for the given resource group.
+      #
+      def get(group)
+        url = build_url(group)
+        response = rest_get(url)
+        JSON.parse(response.body)
+      end
+
+      # Updates the tags for the given resource group.
+      #
+      def update(group, tags)
+        body = {:tags => tags}.to_json
+        url = build_url(group)
+        response = rest_patch(url, body)
+        response.return!
+      end
+
+      private
+
+      def build_url(group = nil, *args)
+        id = armrest_configuration.subscription_id
+        url = File.join(Azure::Armrest::COMMON_URI, id, 'resourcegroups')
+        url = File.join(url, group) if group
+        url = File.join(url, *args) unless args.empty?
+        url << "?api-version=#{@api_version}"
+      end 
+
+    end # ResourceGroupService
+  end # Armrest
+end # Azure

data/lib/azure/armrest/resource_provider_service.rb

@@ -0,0 +1,111 @@
+require 'cache_method'
+
+module Azure
+  module Armrest
+    class ResourceProviderService < ArmrestService
+      # The provider used in http requests. The default is 'Microsoft.Resources'
+      attr_reader :provider
+
+      # The amount of time in seconds to cache certain methods. The default is 24 hours.
+      @cache_time = 24 * 60 * 60
+
+      class << self
+        # Get or set the cache time for all methods. The default is 24 hours.
+        attr_accessor :cache_time
+      end
+
+      # Creates and returns a new ResourceProviderService object.
+      #
+      # Note that many ResourceProviderService instance methods are cached. You
+      # can set the cache_time for certain methods in the constructor, but keep in
+      # mind that it is a global setting for the class. You can also set this
+      # at the class level if desired. The default cache time is 24 hours.
+      #
+      # You can also set the provider. The default is 'Microsoft.Resources'.
+      #
+      def initialize(_armrest_configuration, options = {})
+        super
+
+        @provider = options[:provider] || 'Microsoft.Resources'
+
+        if options[:cache_time]
+          @cache_time = options[:cache_time]
+          self.class.send(:cache_time=, @cache_time)
+        end
+
+        set_service_api_version(options, 'resourceGroups')
+      end
+
+      # List all the providers for the current subscription. The results of
+      # this method are cached.
+      #
+      def list
+        url = build_url
+        response = rest_get(url)
+        JSON.parse(response.body)["value"]
+      end
+
+      cache_method(:list, cache_time)
+
+      # Return information about a specific +namespace+ provider. The results
+      # of this method are cached.
+      #
+      def get(namespace)
+        url = build_url(namespace)
+        response = rest_get(url)
+        JSON.parse(response.body)
+      end
+
+      cache_method(:get, cache_time)
+
+      # Returns an array of geo-locations for the given +namespace+ provider.
+      # The results of this method are cached.
+      #
+      def list_geo_locations(namespace)
+        url = build_url(namespace)
+        response = rest_get(url)
+        JSON.parse(response.body)['resourceTypes'].first['locations']
+      end
+
+      cache_method(:list_geo_locations, cache_time)
+
+      # Returns an array of supported api-versions for the given +namespace+ provider.
+      # The results of this method are cached.
+      #
+      def list_api_versions(namespace)
+        url = build_url(namespace)
+        response = rest_get(url)
+        JSON.parse(response.body)['resourceTypes'].first['apiVersions']
+      end
+
+      cache_method(:list_api_versions, cache_time)
+
+      # Register the current subscription with the +namespace+ provider.
+      #
+      def register(namespace)
+        url = build_url(namespace, 'register')
+        response = rest_post(url)
+        response.return!
+      end
+
+      # Unregister the current subscription from the +namespace+ provider.
+      #
+      def unregister(namespace)
+        url = build_url(namespace, 'unregister')
+        response = rest_post(url)
+        response.return!
+      end
+
+      private
+
+      def build_url(namespace = nil, *args)
+        id = armrest_configuration.subscription_id
+        url = File.join(Azure::Armrest::COMMON_URI, id, 'providers')
+        url = File.join(url, namespace) if namespace
+        url = File.join(url, *args) unless args.empty?
+        url << "?api-version=#{@api_version}"
+      end
+
+    end # ResourceGroupService
+  end # Armrest
+end # Azure

data/lib/azure/armrest/resource_service.rb

@@ -0,0 +1,86 @@
+module Azure
+  module Armrest
+    class ResourceService < ArmrestService
+      # The provider used in http requests. The default is 'Microsoft.Resources'
+      attr_reader :provider
+
+      # Creates and returns a new ResourceService object.
+      #
+      def initialize(_armrest_configuration, options = {})
+        super
+        @provider = options[:provider] || 'Microsoft.Resources'
+        set_service_api_version(options, 'subscriptions')
+      end
+
+      # List all the resources for the current subscription. You can optionally
+      # pass :top or :filter options as well to restrict returned results.
+      #
+      # If you pass a :resource_group option, then only resources for that
+      # resource group are returned.
+      #
+      # Examples:
+      #
+      #   rs = ResourceService.new
+      #   rs.list(:top => 2)
+      #   rs.list(:filter => "location eq 'centralus'")
+      #
+      def list(options = {})
+        subscription_id = armrest_configuration.subscription_id
+
+        if options[:resource_group]
+          url = File.join(
+            Azure::Armrest::COMMON_URI, subscription_id, 'resourcegroups',
+            options[:resource_group], 'resources'
+          )
+        else
+          url = File.join(Azure::Armrest::COMMON_URI, subscription_id, 'resources')
+        end
+
+        url << "?api-version=#{@api_version}"
+        url << "&$top=#{options[:top]}" if options[:top]
+        url << "&$filter=#{options[:filter]}" if options[:filter]
+
+        response = rest_get(URI.escape(url))
+
+        JSON.parse(response.body)["value"]
+      end
+
+      # Move the resources from +source_group+ under +source_subscription+,
+      # which may be a different subscription.
+      #
+      def move(source_group, source_subscription = armrest_configuration.subscription_id)
+        url = File.join(
+          Azure::Armrest::COMMON_URI, source_subscription,
+          'resourcegroups', source_group, 'moveresources'
+        )
+
+        url << "?api-version=#{@api_version}"
+
+        response = rest_post(url)
+        response.return!
+      end
+
+      # Checks to see if the given 'resource_name' and 'resource_type' is allowed.
+      # This returns a JSON string that will indicate the status, including an error
+      # code and message on failure.
+      #
+      # If you want a simple boolean check, use the check_resource? method instead.
+      #
+      def check_resource(resource_name, resource_type)
+        body = JSON.dump(:Name => resource_name, :Type => resource_type)
+        url = File.join(Azure::Armrest::RESOURCE, 'providers', provider, 'checkresourcename')
+        url << "?api-version=#{@api_version}"
+
+        response = rest_post(url, body)
+        response.return!
+      end
+
+      # Similar to the check_resource method, but returns a boolean instead.
+      #
+      def check_resource?(resource_name, resource_type)
+        check_resource(resource_name, resource_type)['status'] == 'Allowed'
+      end
+
+    end # ResourceService
+  end # Armrest
+end # Azure

data/lib/azure/armrest/storage_account_service.rb

@@ -0,0 +1,220 @@
+module Azure
+  module Armrest
+    # Class for managing storage accounts.
+    class StorageAccountService < ArmrestService
+
+      # Valid account types for the create or update method.
+      VALID_ACCOUNT_TYPES = %w[
+        Standard_LRS
+        Standard_ZRS
+        Standard_GRS
+        Standard_RAGRS
+      ]
+
+      # Creates and returns a new StorageAccountService (SAS) instance.
+      #
+      def initialize(_armrest_configuration, options = {})
+        super
+        @provider = options[:provider] || 'Microsoft.Storage'
+        #set_service_api_version(options, 'storageAccounts')
+        @api_version = '2015-05-01-preview' # Must hard code for now
+      end
+
+      # Return information for the given storage account name for the
+      # provided +group+. If no group is specified, it will use the
+      # group set in the constructor.
+      #
+      # If the +include_keys+ option is set to true, then the keys for that
+      # storage account will be included in the output as well.
+      #
+      # Example:
+      #
+      #   sas.get('portalvhds1234', 'Default-Storage-CentralUS')
+      #
+      def get(account_name, group = armrest_configuration.resource_group, include_keys = false)
+        raise ArgumentError, "must specify resource group" unless group
+
+        url = build_url(group, account_name)
+        results = JSON.parse(rest_get(url))
+        results['properties'].merge!(list_account_keys(account_name, group)) if include_keys
+
+        results
+      end
+
+      # Returns a list of available storage accounts for the given subscription
+      # for the provided +group+, or all resource groups if none is provided.
+      #
+      def list(group = nil)
+        if group
+          url = build_url(group)
+          JSON.parse(rest_get(url))['value']
+        else
+          array = []
+          threads = []
+          mutex = Mutex.new
+
+          resource_groups.each do |rg|
+            threads << Thread.new(rg['name']) do |group|
+              url = build_url(group)
+              response = rest_get(url)
+              results = JSON.parse(response)['value']
+              if results && !results.empty?
+                mutex.synchronize{
+                  results.each{ |hash| hash['resourceGroup'] = group }
+                  array << results
+                }
+              end
+            end
+          end
+
+          threads.each(&:join)
+
+          array.flatten
+        end
+      end
+
+      # List all storage accounts for the current subscription. This does not
+      # include storage account key information.
+      #
+      def list_all_for_subscription
+        sub_id = armrest_configuration.subscription_id
+        url = File.join(Azure::Armrest::COMMON_URI, sub_id, 'providers', @provider, 'storageAccounts')
+        url << "?api-version=#{@api_version}"
+        JSON.parse(rest_get(url))
+      end
+
+      alias list_all list_all_for_subscription
+
+      # Creates a new storage account, or updates an existing account with the
+      # specified parameters. The possible parameters are:
+      #
+      # - :name
+      #   Required. The name of the storage account within the specified
+      #   resource stack. Must be 3-24 alphanumeric lowercase characters.
+      #
+      # - :validating
+      #   Optional. Set to 'nameAvailability' to indicate that the account
+      #   name must be checked for global availability.
+      #
+      # - :type
+      #   The type of storage account. The default is "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)
+      #
+      #   sas.create(
+      #     :name     => "yourstorageaccount1",
+      #     :location => "West US",
+      #     :type     => "Standard_ZRS",
+      #     :tags     => {:YourCompany => true}
+      #   )
+      #
+      # For convenience you may also specify the :resource_group as an option.
+      #
+      def create(options = {}, rgroup = armrest_configuration.resource_group)
+        rgroup ||= options[:resource_group]
+        raise ArgumentError, "No resource group specified" if rgroup.nil?
+
+        # Mandatory options
+        name = options.fetch(:name)
+        location = options.fetch(:location)
+
+        # Optional
+        tags = options[:tags]
+        type = options[:type] || "Standard_GRS"
+
+        properties = {:accountType => type}
+
+        validate_account_type(type)
+        validate_account_name(name)
+
+        url = build_url(rgroup, name)
+        url << "&validating=" << options[:validating] if options[:validating]
+
+        body = {
+          :name       => name,
+          :location   => location,
+          :tags       => tags,
+          :properties => properties
+        }.to_json
+
+        response = rest_put(url, body)
+        response.return!
+      end
+
+      alias update create
+
+      # Delete the given storage account name.
+      #
+      def delete(account_name, group = armrest_configuration.resource_group)
+        raise ArgumentError, "must specify resource group" unless group
+
+        url = build_url(group, account_name)
+        response = rest_delete(url)
+        response.return!
+      end
+
+      # Returns the primary and secondary access keys for the given
+      # storage account.
+      #
+      def list_account_keys(account_name, group = armrest_configuration.resource_group)
+        raise ArgumentError, "must specify resource group" unless group
+
+        url = build_url(group, account_name, 'listKeys')
+        response = rest_post(url)
+        JSON.parse(response)
+      end
+
+      # Regenerates the primary and secondary access keys for the given
+      # storage account.
+      #
+      def regenerate_storage_account_keys(account_name)
+        raise ArgumentError, "must specify resource group" unless group
+
+        url = build_url(group, account_name, 'regenerateKey')
+        response = rest_post(url)
+        response.return!
+      end
+
+      private
+
+      def validate_account_type(account_type)
+        unless VALID_ACCOUNT_TYPES.include?(account_type)
+          raise ArgumentError, "invalid account type '#{account_type}'"
+        end
+      end
+
+      def validate_account_name(name)
+        if name.size < 3 || name.size > 24 || name[/\W+/]
+          raise ArgumentError, "name must be 3-24 alpha-numeric characters only"
+        end
+      end
+
+      # Builds a URL based on subscription_id an resource_group and any other
+      # arguments provided, and appends it with the api-version.
+      def build_url(resource_group, *args)
+        url = File.join(
+          Azure::Armrest::COMMON_URI,
+          armrest_configuration.subscription_id,
+          'resourceGroups',
+          resource_group,
+          'providers',
+          @provider,
+          'storageAccounts',
+        )
+
+        url = File.join(url, *args) unless args.empty?
+        url << "?api-version=#{@api_version}"
+      end
+    end
+  end
+end