fog-azure-rm 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 086b6f020bf8dccb6fe47578df34eacfac015719
+  data.tar.gz: 584f0ad3a486c34686af2cdfc7e470c0d730bd77
+SHA512:
+  metadata.gz: 8b228877689c27b572c230aa1eb60f75adae338133ff3b902eca215fc1dec4f8e798c1a780621add6c8908b77cd5fb4b5fc4fae1f6d0fd13a0b2b96530a6f490
+  data.tar.gz: 8d6ad541e4b35af0f57e7d7fcc4036835774086f94360325beeb367697c5585f01041430d5d81ef2df12e61e0bb83b4a5d9ccb9f1ee4a5a762e9831a9605a48b

data/CONTRIBUTING.md

@@ -0,0 +1,27 @@
+## Getting Involved
+
+New contributors are always welcome, when it doubt please ask questions. We strive to be an open and welcoming community. Please be nice to one another.
+
+### Coding
+
+* Pick a task:
+  * Offer feedback on open [pull requests](https://github.com/Confiz/fog-azure-rm/pulls).
+  * Review open [issues](https://github.com/Confiz/fog-azure-rm/issues) for things to help on.
+  * [Create an issue](https://github.com/Confiz/fog-azure-rm/issues/new) to start a discussion on additions or features.
+* Fork the project, add your changes and tests to cover them in a topic branch.
+  * [Fork](https://github.com/Confiz/fog-azure-rm/fork)
+  * Create your feature branch (`git checkout -b my-new-feature`)
+  * Commit your changes (`git commit -am 'Add some feature'`)
+  * Push to the branch (`git push origin my-new-feature`)
+  * Create a new pull request
+* Commit your changes and rebase against `Confiz/fog-azure-rm` to ensure everything is up to date.
+* [Submit a pull request](https://github.com/Confiz/fog-azure-rm/compare/).
+
+### Non-Coding
+
+* Offer feedback on open [issues](https://github.com/Confiz/fog-azure-rm/issues).
+* Organize or volunteer at events.
+* Write and help edit [documentation](https://github.com/Confiz/fog-azure-rm/tree/develop/lib/fog/azurerm/docs).
+
+## Testing 
+

data/CONTRIBUTORS.md

@@ -0,0 +1,4 @@
+
+* Adnan Khalil <adnan.khalil@confiz.com>
+* Samawia Moin <samawia.moin@confiz.com>
+* Shaffan Chaudhry <shaffan.chaudhry@confiz.com>

data/LICENSE.md

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2015 [CONTRIBUTORS.md](https://github.com/Confiz/fog-azure-rm/blob/develop/CONTRIBUTORS.md)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,82 @@
+# Fog Azure Resource Manager
+
+This document describes how to get started with Fog using Microsoft Azure as a cloud resource management services provider.
+
+## Pre-requisites
+
+* Fog supports Ruby version 2.0.0 or later
+* Fog requires Azure SDK For Ruby version 0.2.1. 
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'fog-azure-rm'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install fog-azure-rm
+    
+    
+## Usage
+
+You can use this gem against the Microsoft Azure Resource Manager Services in the cloud. Of course, to use the Microsoft Azure Resource Manager Services in the cloud, you need to first [create a Microsoft Azure account](http://www.azure.com/en-us/pricing/free-trial/).
+
+
+### Authentication
+
+The next step to use this gem, is authentication and permissioning. It is important to get familiar with this concept. For a reference on setting up a service principal from the command line see
+[Authenticating a service principal with Azure Resource Manager](http://aka.ms/cli-service-principal) or
+[Unattended Authentication](http://aka.ms/auth-unattended). For a more robust explanation of authentication in Azure,
+see [Developer’s guide to auth with Azure Resource Manager API](http://aka.ms/arm-auth-dev-guide).
+
+After creating the service principal, you should have three pieces of information, a client id (GUID), client secret
+(string) and tenant id (GUID).
+
+### Compute
+
+  Fog-AzureRM for compute includes implementaion of Virtual Machines and Availability Sets. Readme for the usage of [Compute](https://github.com/Confiz/fog-azure-rm/blob/develop/lib/fog/azurerm/docs/compute.md) module.
+
+### Resources
+
+  Fog-AzureRM for resources includes implementaion of Resource Groups. Readme for the usage of [Resources](https://github.com/Confiz/fog-azure-rm/blob/develop/lib/fog/azurerm/docs/resources.md) module.
+
+### DNS
+
+  Fog-AzureRM for dns includes implementaion of Record sets and Zones. Readme for the usage of [DNS](https://github.com/Confiz/fog-azure-rm/blob/develop/lib/fog/azurerm/docs/dns.md) module.
+
+### Network
+
+  Fog-AzureRM for network includes implementaion of Network Interfaces, Public IPs, Subnets and Virtual Networks. Readme for the usage of [Network](https://github.com/Confiz/fog-azure-rm/blob/develop/lib/fog/azurerm/docs/network.md) module.
+
+### Storage
+
+  Fog-AzureRM for storage includes implementaion of Storage Accounts. Readme for the usage of [Storage](https://github.com/Confiz/fog-azure-rm/blob/develop/lib/fog/azurerm/docs/storage.md) module.
+  
+## Supported Services
+
+Use following command for the complete list of services, Fog provides for Azure Resource Manager.
+
+```ruby
+Fog::AzureRM.services
+```
+
+  
+## Contributing
+
+See [CONTRIBUTING.md](https://github.com/Confiz/fog-azure-rm/blob/develop/CONTRIBUTING.md) in this repository.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+
+
+
+

data/lib/fog/azurerm.rb

@@ -0,0 +1,40 @@
+require 'ms_rest_azure'
+require 'rest_client'
+require 'erb'
+require 'fog/azurerm/config'
+require 'fog/azurerm/version'
+require 'fog/azurerm/core'
+require 'fog/azurerm/dns'
+require 'fog/azurerm/resources'
+require 'fog/azurerm/storage'
+require 'fog/azurerm/network'
+require 'fog/azurerm/compute'
+
+
+module Fog
+  module AzureRM
+    def self.services
+      begin
+        array_of_services = []
+        ENV['BUNDLE_GEM'] = File.expand_path('../../lib', File.dirname(__FILE__))
+        gem_path = ENV['BUNDLE_GEM']
+        files = Dir.entries(File.join(gem_path,'/fog/azurerm')).select {|f| !File.directory? f}
+        files.each do |file|
+          next if file == "config.rb"
+          next if file == "core.rb"
+          next if file == "credentials.rb"
+          next if file == "docs"
+          next if file == "models"
+          next if file == "requests"
+          next if file == "version.rb"
+          array_of_services.push((file.split(".").first).upcase)
+        end
+        array_of_services
+      rescue => e
+        Fog::Logger.warning(e.message)
+        raise e.message
+        # typically occurs if folder_to_count does not exist
+      end
+    end
+  end
+end

data/lib/fog/azurerm/compute.rb

@@ -0,0 +1,61 @@
+require 'fog/azurerm/core'
+# rubocop:disable LineLength
+module Fog
+  module Compute
+    # This class registers models, requests and collections
+    class AzureRM < Fog::Service
+      requires :tenant_id
+      requires :client_id
+      requires :client_secret
+      requires :subscription_id
+
+      request_path 'fog/azurerm/requests/compute'
+      request :create_availability_set
+      request :delete_availability_set
+      request :list_availability_sets
+      request :create_virtual_machine
+      request :delete_virtual_machine
+      request :get_virtual_machine
+      request :list_virtual_machines
+      request :list_available_sizes_for_virtual_machine
+      request :generalize_virtual_machine
+      request :deallocate_virtual_machine
+      request :power_off_virtual_machine
+      request :redeploy_virtual_machine
+      request :restart_virtual_machine
+      request :start_virtual_machine
+
+      model_path 'fog/azurerm/models/compute'
+      model :availability_set
+      collection :availability_sets
+      model :server
+      collection :servers
+      # This class provides the mock implementation for unit tests.
+      class Mock
+        def initialize(_options = {})
+          begin
+            require 'azure_mgmt_compute'
+          rescue LoadError => e
+            retry if require('rubygems')
+            raise e.message
+          end
+        end
+      end
+      # This class provides the actual implemention for service calls.
+      class Real
+        def initialize(options)
+          begin
+            require 'azure_mgmt_compute'
+          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])
+          @compute_mgmt_client = ::Azure::ARM::Compute::ComputeManagementClient.new(credentials)
+          @compute_mgmt_client.subscription_id = options[:subscription_id]
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/config.rb

@@ -0,0 +1 @@
+AZURE_RESOURCE = 'https://management.azure.com'

data/lib/fog/azurerm/core.rb

@@ -0,0 +1,12 @@
+require 'fog/core'
+
+module Fog
+  module AzureRM
+    extend Fog::Provider
+    service(:resources, 'Resources')
+    service(:dns, 'DNS')
+    service(:storage, 'Storage')
+    service(:network, 'Network')
+    service(:compute, 'Compute')
+  end
+end

data/lib/fog/azurerm/credentials.rb

@@ -0,0 +1,37 @@
+module Fog
+  module Credentials
+    class AzureRM
+
+      def self.get_credentials(tenant_id, client_id, client_secret)
+        if @credentials.nil? || new_client(tenant_id, client_id, client_secret)
+          get_new_credentials(tenant_id, client_id, client_secret)
+        else
+          @credentials
+        end
+      end
+
+      def self.get_token(tenant_id, client_id, client_secret)
+        get_credentials(tenant_id, client_id, client_secret) if @credentials.nil?
+        @token_provider.get_authentication_header
+      end
+
+      def self.get_new_credentials(tenant_id, client_id, client_secret)
+        @tenant_id = tenant_id
+        @client_id = client_id
+        @client_secret = client_secret
+        @token_provider = MsRestAzure::ApplicationTokenProvider.new(@tenant_id, @client_id, @client_secret)
+        @credentials = MsRest::TokenCredentials.new(@token_provider)
+        @credentials
+      end
+
+      def self.new_client(tenant_id, client_id, client_secret)
+        @tenant_id != tenant_id ||
+            @client_id != client_id ||
+            @client_secret != client_secret
+      end
+
+      private_class_method :get_new_credentials
+      private_class_method :new_client
+    end
+  end
+end

data/lib/fog/azurerm/dns.rb

@@ -0,0 +1,48 @@
+require 'fog/azurerm/core'
+require 'fog/azurerm/credentials'
+
+module Fog
+  module DNS
+    class AzureRM < Fog::Service
+      requires :tenant_id
+      requires :client_id
+      requires :client_secret
+      requires :subscription_id
+
+      request_path 'fog/azurerm/requests/dns'
+      request :create_zone
+      request :delete_zone
+      request :check_for_zone
+      request :list_zones
+      request :create_record_set
+      request :delete_record_set
+      request :list_record_sets
+      request :get_records_from_record_set
+
+      model_path 'fog/azurerm/models/dns'
+      model :zone
+      collection :zones
+      model :record_set
+      collection :record_sets
+
+      class Mock
+        def initialize(options = {})
+        end
+      end
+
+      class Real
+        def initialize(options)
+          @tenant_id = options[:tenant_id]
+          @client_id = options[:client_id]
+          @client_secret = options[:client_secret]
+          @subscription_id = options[:subscription_id]
+          @resources = Fog::Resources::AzureRM.new(
+              tenant_id: options[:tenant_id],
+              client_id: options[:client_id],
+              client_secret: options[:client_secret],
+              subscription_id: options[:subscription_id])
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/compute/availability_set.rb

@@ -0,0 +1,31 @@
+# rubocop:disable MethodLength
+# rubocop:disable AbcSize
+module Fog
+  module Compute
+    class AzureRM
+      # This class is giving implementation of create/save and
+      # delete/destroy for Availability Set.
+      class AvailabilitySet < Fog::Model
+        attribute :id
+        identity  :name
+        attribute :type
+        attribute :location
+        attribute :tags
+        attribute :resource_group
+        attribute :properties
+
+        def save
+          requires :name
+          requires :location
+          requires :resource_group
+          # need to create the availability set
+          service.create_availability_set(resource_group, name, location)
+        end
+
+        def destroy
+          service.delete_availability_set(resource_group, name)
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/compute/availability_sets.rb

@@ -0,0 +1,36 @@
+require 'fog/core/collection'
+require 'fog/azurerm/models/compute/availability_set'
+# rubocop:disable MethodLength
+module Fog
+  module Compute
+    class AzureRM
+      # This class is giving implementation of all/list, get and
+      # check name availability for storage account.
+      class AvailabilitySets < Fog::Collection
+        model Fog::Compute::AzureRM::AvailabilitySet
+        attribute :resource_group
+        def all
+          accounts = []
+          requires :resource_group
+          list_of_availability_sets =
+            service.list_availability_sets(resource_group)
+          unless list_of_availability_sets.nil?
+            list_of_availability_sets.each do |account|
+              hash = {}
+              account.instance_variables.each do |var|
+                hash[var.to_s.delete('@')] = account.instance_variable_get(var)
+              end
+              hash['resource_group'] = resource_group
+              accounts << hash
+            end
+          end
+          load(accounts)
+        end
+
+        def get(resource_group, identity)
+          all.find { |as| as.resource_group == resource_group && as.name == identity }
+        end
+      end
+    end
+  end
+end

data/lib/fog/azurerm/models/compute/server.rb

@@ -0,0 +1,94 @@
+module Fog
+  module Compute
+    class AzureRM
+      # This class is giving implementation of create/save and
+      # delete/destroy for Virtual Machine.
+      class Server < Fog::Model
+        attribute :id
+        identity  :name
+        attribute :location
+        attribute :resource_group
+        attribute :vm_size
+        attribute :storage_account_name
+        attribute :os_disk_name
+        attribute :vhd_uri
+        attribute :publisher
+        attribute :offer
+        attribute :sku
+        attribute :version
+        attribute :username
+        attribute :password
+        attribute :disable_password_authentication
+        attribute :ssh_key_path
+        attribute :ssh_key_data
+        attribute :network_interface_card_id
+        attribute :availability_set_id
+
+        def self.parse(vm)
+          hash = {}
+          hash['id'] = vm['id']
+          hash['name'] = vm['name']
+          hash['location'] = vm['location']
+          hash['resource_group'] = vm['id'].split('/')[4]
+          hash['vm_size'] = vm['properties']['hardwareProfile']['vmSize']
+          hash['os_disk_name'] = vm['properties']['storageProfile']['osDisk']['name']
+          hash['vhd_uri'] = vm['properties']['storageProfile']['osDisk']['vhd']['uri']
+          hash['publisher'] = vm['properties']['storageProfile']['imageReference']['publisher']
+          hash['offer'] = vm['properties']['storageProfile']['imageReference']['offer']
+          hash['sku'] = vm['properties']['storageProfile']['imageReference']['sku']
+          hash['version'] = vm['properties']['storageProfile']['imageReference']['version']
+          hash['username'] = vm['properties']['osProfile']['adminUsername']
+          hash['disable_password_authentication'] = vm['properties']['osProfile']['linuxConfiguration']['disablePasswordAuthentication']
+          hash['network_interface_card_id'] = vm['properties']['networkProfile']['networkInterfaces'][0]['id']
+          hash['availability_set_id'] = vm['properties']['availabilitySet']['id'] unless vm['properties']['availabilitySet'].nil?
+          hash
+        end
+
+        def save
+          requires :name, :location, :resource_group, :vm_size, :storage_account_name,
+                   :username, :password, :disable_password_authentication,
+                   :network_interface_card_id, :publisher, :offer, :sku, :version
+
+          ssh_key_path = "/home/#{username}/.ssh/authorized_keys" unless ssh_key_data.nil?
+          vm = service.create_virtual_machine(name, location, resource_group, vm_size, storage_account_name,
+                                         username, password, disable_password_authentication,
+                                         ssh_key_path, ssh_key_data, network_interface_card_id,
+                                         availability_set_id, publisher, offer, sku, version)
+          merge_attributes(Fog::Compute::AzureRM::Server.parse(vm))
+        end
+
+        def destroy
+          service.delete_virtual_machine(resource_group, name)
+        end
+
+        def generalize
+          service.generalize_virtual_machine(resource_group, name)
+        end
+
+        def power_off
+          service.power_off_virtual_machine(resource_group, name)
+        end
+
+        def start
+          service.start_virtual_machine(resource_group, name)
+        end
+
+        def restart
+          service.restart_virtual_machine(resource_group, name)
+        end
+
+        def deallocate
+          service.deallocate_virtual_machine(resource_group, name)
+        end
+
+        def redeploy
+          service.redeploy_virtual_machine(resource_group, name)
+        end
+
+        def list_available_sizes
+          service.list_available_sizes_for_virtual_machine(resource_group, name)
+        end
+      end
+    end
+  end
+end