vagrant-azure 1.3.0 → 2.0.0.pre1

data/lib/vagrant-azure/action/read_state.rb

@@ -1,46 +1,48 @@
-#--------------------------------------------------------------------------
-# Copyright (c) Microsoft Open Technologies, Inc.
-# All Rights Reserved.  Licensed under the Apache License, Version 2.0.
-# See License.txt in the project root for license information.
-#--------------------------------------------------------------------------
+# encoding: utf-8
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License in the project root for license information.
 require 'log4r'
+require 'vagrant-azure/util/vm_status_translator'
+require 'vagrant-azure/util/machine_id_helper'
 
 module VagrantPlugins
-  module WinAzure
+  module Azure
     module Action
       class ReadState
+        include VagrantPlugins::Azure::Util::VMStatusTranslator
+        include VagrantPlugins::Azure::Util::MachineIdHelper
+
         def initialize(app, env)
           @app = app
           @logger = Log4r::Logger.new('vagrant_azure::action::read_state')
         end
 
         def call(env)
-          env[:machine_state_id] = read_state(env)
-
+          env[:machine_state_id] = read_state(env[:azure_arm_service], env[:machine])
           @app.call(env)
         end
 
-        def read_state(env)
-          env[:machine].id = "#{env[:machine].provider_config.vm_name}@#{env[:machine].provider_config.cloud_service_name}" unless env[:machine].id
-
-          env[:machine].id =~ /@/
-
-          env[:ui].info "Attempting to read state for #{$`} in #{$'}"
-
-          vm = env[:azure_vm_service].get_virtual_machine($`, $')
-
-          if vm.nil? || \
-            !vm.instance_of?(Azure::VirtualMachineManagement::VirtualMachine) || \
-            [ :DeletingVM ].include?(vm.status.to_sym)
-            # Machine can't be found
-            @logger.info 'Machine cannot be found'
-            env[:machine].id = nil
-            return :NotCreated
+        def read_state(azure, machine)
+          return :not_created if machine.id.nil?
+
+          # Find the machine
+          parsed = parse_machine_id(machine.id)
+          vm = nil
+          begin
+            vm = azure.compute.virtual_machines.get(parsed[:group], parsed[:name], 'instanceView').value!.body
+          rescue MsRestAzure::AzureOperationError => ex
+            if vm.nil? || tearing_down?(vm.properties.instance_view.statuses)
+              # The machine can't be found
+              @logger.info('Machine not found or terminated, assuming it got destroyed.')
+              machine.id = nil
+              return :not_created
+            end
           end
 
-          env[:ui].info "VM Status: #{vm.status.to_sym}"
-          return vm.status.to_sym
+          # Return the state
+          power_state(vm.properties.instance_view.statuses)
         end
+
       end
     end
   end

data/lib/vagrant-azure/action/restart_vm.rb

@@ -1,25 +1,25 @@
-#--------------------------------------------------------------------------
-# Copyright (c) Microsoft Open Technologies, Inc.
-# All Rights Reserved.  Licensed under the Apache License, Version 2.0.
-# See License.txt in the project root for license information.
-#--------------------------------------------------------------------------
+# encoding: utf-8
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License in the project root for license information.
 require 'log4r'
+require 'vagrant-azure/util/machine_id_helper'
 
 module VagrantPlugins
-  module WinAzure
+  module Azure
     module Action
       class RestartVM
+        include VagrantPlugins::Azure::Util::MachineIdHelper
+
         def initialize(app, env)
           @app = app
           @logger = Log4r::Logger.new('vagrant_azure::action::restart_vm')
         end
 
         def call(env)
-          env[:machine].id =~ /@/
-
-          env[:ui].info "Restarting #{$`} in #{$'}"
-          env[:azure_vm_service].restart_virtual_machine($`, $')
-
+          parsed = parse_machine_id(env[:machine].id)
+          env[:ui].info(I18n.t('vagrant_azure.restarting', parsed))
+          env[:azure_arm_service].compute.virtual_machines.restart(parsed[:group], parsed[:name])
+          env[:ui].info(I18n.t('vagrant_azure.restarted', parsed))
           @app.call(env)
         end
       end

data/lib/vagrant-azure/action/run_instance.rb

@@ -1,20 +1,20 @@
-#---------------------------------------------------------------------------
-# Copyright (c) Microsoft Open Technologies, Inc.
-# All Rights Reserved.  Licensed under the Apache License, Version 2.0.
-# See License.txt in the project root for license information.
-#--------------------------------------------------------------------------
+# encoding: utf-8
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License in the project root for license information.
 require 'log4r'
 require 'json'
-require 'azure'
-require 'openssl'
-
-require 'vagrant/util/retryable'
+require 'azure_mgmt_resources'
+require 'vagrant/util/template_renderer'
+require 'vagrant-azure/util/timer'
+require 'vagrant-azure/util/machine_id_helper'
+require 'haikunator'
 
 module VagrantPlugins
-  module WinAzure
+  module Azure
     module Action
       class RunInstance
         include Vagrant::Util::Retryable
+        include VagrantPlugins::Azure::Util::MachineIdHelper
 
         def initialize(app, env)
           @app = app
@@ -22,97 +22,181 @@ module VagrantPlugins
         end
 
         def call(env)
-          config = env[:machine].provider_config
-
-          # Add the mandatory parameters and options
-          params = {
-              vm_name: config.vm_name,
-              vm_user: config.vm_user,
-              image: config.vm_image
-          }
-
-          options = {
-              cloud_service_name: config.cloud_service_name
+          # Initialize metrics if they haven't been
+          env[:metrics] ||= {}
+
+          machine = env[:machine]
+
+          # Get the configs
+          config                    = machine.provider_config
+          endpoint                  = config.endpoint
+          resource_group_name       = config.resource_group_name
+          location                  = config.location
+          vm_name                   = config.vm_name
+          vm_password               = config.vm_password
+          vm_size                   = config.vm_size
+          vm_image_urn              = config.vm_image_urn
+          virtual_network_name      = config.virtual_network_name
+          subnet_name               = config.subnet_name
+          tcp_endpoints             = config.tcp_endpoints
+          availability_set_name     = config.availability_set_name
+
+          # Launch!
+          env[:ui].info(I18n.t('vagrant_azure.launching_instance'))
+          env[:ui].info(" -- Management Endpoint: #{endpoint}")
+          env[:ui].info(" -- Subscription Id: #{config.subscription_id}")
+          env[:ui].info(" -- Resource Group Name: #{resource_group_name}")
+          env[:ui].info(" -- Location: #{location}")
+          env[:ui].info(" -- VM Name: #{vm_name}")
+          env[:ui].info(" -- VM Size: #{vm_size}")
+          env[:ui].info(" -- Image URN: #{vm_image_urn}")
+          env[:ui].info(" -- Virtual Network Name: #{virtual_network_name}") if virtual_network_name
+          env[:ui].info(" -- Subnet Name: #{subnet_name}") if subnet_name
+          env[:ui].info(" -- TCP Endpoints: #{tcp_endpoints}") if tcp_endpoints
+          env[:ui].info(" -- Availability Set Name: #{availability_set_name}") if availability_set_name
+
+          image_publisher, image_offer, image_sku, image_version = vm_image_urn.split(':')
+
+          azure = env[:azure_arm_service]
+          image_details = nil
+          env[:metrics]['get_image_details'] = Util::Timer.time do
+            image_details = get_image_details(azure, location, image_publisher, image_offer, image_sku, image_version)
+          end
+          @logger.info("Time to fetch os image details: #{env[:metrics]['get_image_details']}")
+
+          deployment_params = {
+            dnsLabelPrefix:       Haikunator.haikunate(100),
+            vmSize:               vm_size,
+            vmName:               vm_name,
+            imagePublisher:       image_publisher,
+            imageOffer:           image_offer,
+            imageSku:             image_sku,
+            imageVersion:         image_version,
+            subnetName:           subnet_name,
+            virtualNetworkName:   virtual_network_name
           }
 
+          if get_image_os(image_details) != 'Windows'
+            private_key_paths = machine.config.ssh.private_key_path
+            if private_key_paths.empty?
+              raise I18n.t('vagrant_azure.private_key_not_specified')
+            end
 
-          # Add the optional parameters and options if not nil
-          params[:password] = config.vm_password unless config.vm_password.nil?
-          params[:location] = config.vm_location unless config.vm_location.nil?
-          params[:affinity_group] = config.vm_affinity_group unless config.vm_affinity_group.nil?
+            paths_to_pub = private_key_paths.map{ |k| File.expand_path( k + '.pub') }.select{ |p| File.exists?(p) }
+            raise I18n.t('vagrant_azure.public_key_path_private_key', private_key_paths.join(', ')) if paths_to_pub.empty?
+            deployment_params.merge!(sshKeyData: File.read(paths_to_pub.first))
+          end
 
-          options[:storage_account_name] = config.storage_acct_name unless config.storage_acct_name.nil?
-          options[:deployment_name] = config.deployment_name unless config.deployment_name.nil?
-          options[:tcp_endpoints] = config.tcp_endpoints unless config.tcp_endpoints.nil?
+          template_params = {
+              operating_system:   get_image_os(image_details)
+          }
 
-          unless config.private_key_file.nil? && env[:machine].config.ssh.private_key_path.nil?
-            options[:private_key_file] = File.expand_path(config.private_key_file || env[:machine].config.ssh.private_key_path.first)
+          env[:ui].info(" -- Create or Update of Resource Group: #{resource_group_name}")
+          env[:metrics]['put_resource_group'] = Util::Timer.time do
+            put_resource_group(azure, resource_group_name, location)
           end
+          @logger.info("Time to create resource group: #{env[:metrics]['put_resource_group']}")
 
-          options[:ssh_port] = config.ssh_port unless config.ssh_port.nil?
-          options[:vm_size] = config.vm_size unless config.vm_size.nil?
-          options[:winrm_transport] = config.winrm_transport unless config.winrm_transport.nil?
-          options[:winrm_http_port] = config.winrm_http_port unless config.winrm_http_port.nil?
-          options[:winrm_https_port] = config.winrm_https_port unless config.winrm_https_port.nil?
-          options[:availability_set_name] = config.availability_set_name unless config.availability_set_name.nil?
-          options[:virtual_network_name] = config.vm_virtual_network_name unless config.vm_virtual_network_name.nil?
+          deployment_params = build_deployment_params(template_params, deployment_params.reject{|_,v| v.nil?})
 
-
-          if params[:password] && options[:private_key_file]
-            env[:ui].warn('You specified both a password and a private key file. The password will be used rather than ' +
-                                'the private key. If you would like to use asymmetric key auth, do not specify a password.')
+          env[:ui].info('Starting deployment')
+          env[:metrics]['deployment_time'] = Util::Timer.time do
+            put_deployment(azure, resource_group_name, deployment_params)
           end
-
-          add_role = false
-
-          env[:ui].info(params.inspect)
-          env[:ui].info(options.inspect)
-
-          server = VagrantPlugins::WinAzure::CLOUD_SERVICE_SEMAPHORE.synchronize do
-            # Check if the cloud service exists and if yes, does it contain
-            # a deployment.
-            if config.cloud_service_name && !config.cloud_service_name.empty?
-              begin
-                cloud_service = Azure::BaseManagement::ManagementHttpRequest.new(
-                    :get,
-                    "/services/hostedservices/#{config.cloud_service_name}?embed-detail=true"
-                ).call
-
-                deployments = cloud_service.css 'HostedService Deployments Deployment'
-
-                # Lets see if any deployments exist. Set add_role = true if yes.
-                # We're not worried about deployment slots, because the SDK has
-                # hard coded 'Production' as deployment slot and you can have only
-                # one deployment per deployment slot.
-                add_role = deployments.length == 1
-              rescue Exception => e
-                add_role = false
+          env[:ui].info('Finished deploying')
+
+          # Immediately save the ID since it is created at this point.
+          env[:machine].id = serialize_machine_id(resource_group_name, vm_name, location)
+
+          @logger.info("Time to deploy: #{env[:metrics]['deployment_time']}")
+          unless env[:interrupted]
+            env[:metrics]['instance_ssh_time'] = Util::Timer.time do
+              # Wait for SSH to be ready.
+              env[:ui].info(I18n.t('vagrant_azure.waiting_for_ssh'))
+              network_ready_retries = 0
+              network_ready_retries_max = 10
+              while true
+                break if env[:interrupted]
+                begin
+                  break if env[:machine].communicate.ready?
+                rescue Exception => e
+                  if network_ready_retries < network_ready_retries_max
+                    network_ready_retries += 1
+                    @logger.warn(I18n.t('vagrant_azure.waiting_for_ssh, retrying'))
+                  else
+                    raise e
+                  end
+                end
+                sleep 2
               end
             end
 
-            env[:ui].info("Add Role? - #{add_role}")
+            @logger.info("Time for SSH ready: #{env[:metrics]['instance_ssh_time']}")
 
-            if add_role
-              env[:azure_vm_service].add_role(params.clone.merge(cloud_service_name: config.cloud_service_name), options)
-            else
-              env[:azure_vm_service].create_virtual_machine(params, options)
-            end
+            # Ready and booted!
+            env[:ui].info(I18n.t('vagrant_azure.ready'))
           end
 
-          if server.nil?
-            raise Errors::CreateVMFailure
+          # Terminate the instance if we were interrupted
+          terminate(env) if env[:interrupted]
+
+          @app.call(env)
+        end
+
+        def get_image_os(image_details)
+          image_details.properties.os_disk_image.operating_system
+        end
+
+        def get_image_details(azure, location, publisher, offer, sku, version)
+          if version == 'latest'
+            latest = azure.compute.virtual_machine_images.list(location, publisher, offer, sku).value!.body.last
+            azure.compute.virtual_machine_images.get(location, publisher, offer, sku, latest.name).value!.body
+          else
+            azure.compute.virtual_machine_images.get(location, publisher, offer, sku, version).value!.body
           end
+        end
 
-          # The Ruby SDK returns any exception encountered on create virtual
-          # machine as a string.
+        def put_deployment(azure, rg_name, params)
+          azure.resources.deployments.create_or_update(rg_name, 'vagrant', params).value!.body
+        end
 
-          if server.instance_of? String
-            raise Errors::ServerNotCreated, message: server
+        def put_resource_group(azure, name, location)
+          params = ::Azure::ARM::Resources::Models::ResourceGroup.new.tap do |rg|
+            rg.location = location
           end
 
-          env[:machine].id = "#{server.vm_name}@#{server.cloud_service_name}"
+          azure.resources.resource_groups.create_or_update(name, params).value!.body
+        end
 
-          @app.call(env)
+        # This method generates the deployment template
+        def render_deployment_template(options)
+          Vagrant::Util::TemplateRenderer.render('arm/deployment.json', options.merge(template_root: template_root))
+        end
+
+        def build_deployment_params(template_params, deployment_params)
+          params = ::Azure::ARM::Resources::Models::Deployment.new
+          params.properties = ::Azure::ARM::Resources::Models::DeploymentProperties.new
+          params.properties.template = JSON.parse(render_deployment_template(template_params))
+          params.properties.mode = ::Azure::ARM::Resources::Models::DeploymentMode::Incremental
+          params.properties.parameters = build_parameters(deployment_params)
+          params
+        end
+
+        def build_parameters(options)
+          Hash[*options.map{ |k, v| [k,  {value: v}] }.flatten]
+        end
+
+        # Used to find the base location of aws-vagrant templates
+        def template_root
+          Azure.source_root.join('templates')
+        end
+
+        def terminate(env)
+          destroy_env = env.dup
+          destroy_env.delete(:interrupted)
+          destroy_env[:config_validate] = false
+          destroy_env[:force_confirm_destroy] = true
+          env[:action_runner].run(Action.action_destroy, destroy_env)
         end
       end
     end

data/lib/vagrant-azure/action/start_instance.rb

@@ -1,32 +1,51 @@
-#--------------------------------------------------------------------------
-# Copyright (c) Microsoft Open Technologies, Inc.
-# All Rights Reserved.  Licensed under the Apache License, Version 2.0.
-# See License.txt in the project root for license information.
-#--------------------------------------------------------------------------
+# encoding: utf-8
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License in the project root for license information.
 require 'log4r'
+require 'vagrant-azure/util/machine_id_helper'
+require 'vagrant-azure/util/vm_status_translator'
+require 'vagrant/util/retryable'
+require 'vagrant-azure/util/timer'
+require 'vagrant-azure/util/vm_await'
 
-# require 'vagrant/util/retryable'
-
-# Barebones basic implemenation. This a work in progress in very early stages
 module VagrantPlugins
-  module WinAzure
+  module Azure
     module Action
       # This starts a stopped instance
       class StartInstance
+        include VagrantPlugins::Azure::Util::MachineIdHelper
+        include VagrantPlugins::Azure::Util::VMStatusTranslator
+        include VagrantPlugins::Azure::Util::VMAwait
 
         def initialize(app, env)
           @app = app
-          @logger = Log4r::Logger.new('vagrant_azure:action::start_instance')
+          @logger = Log4r::Logger.new('vagrant_azure::action::start_instance')
         end
 
         def call(env)
-          env[:machine].id = "#{env[:machine].provider_config.vm_name}@#{env[:machine].provider_config.cloud_service_name}" unless env[:machine].id
-          env[:machine].id =~ /@/
+          env[:metrics] ||= {}
+
+          parsed = parse_machine_id(env[:machine].id)
+          azure = env[:azure_arm_service]
+          env[:ui].info(I18n.t('vagrant_azure.starting', parsed))
+          azure.compute.virtual_machines.start(parsed[:group], parsed[:name])
+
+          # Wait for the instance to be ready first
+          env[:metrics]['instance_ready_time'] = Util::Timer.time do
 
-          VagrantPlugins::WinAzure::CLOUD_SERVICE_SEMAPHORE.synchronize do
-            env[:ui].info "Attempting to start '#{$`}' in '#{$'}'"
-            env[:azure_vm_service].start_virtual_machine($`, $')
+            env[:ui].info(I18n.t('vagrant_azure.waiting_for_ready'))
+
+            task = await_true(env) do |vm|
+              running?(vm.properties.instance_view.statuses)
+            end
+
+            if task.value
+              env[:ui].info(I18n.t('vagrant_azure.started', parsed))
+            else
+              raise I18n.t('vagrant_azure.errors.failed_starting', parsed) unless env[:interrupted]
+            end
           end
+
           @app.call(env)
         end
       end

data/lib/vagrant-azure/action/stop_instance.rb

@@ -1,15 +1,19 @@
-#--------------------------------------------------------------------------
-# Copyright (c) Microsoft Open Technologies, Inc.
-# All Rights Reserved.  Licensed under the Apache License, Version 2.0.
-# See License.txt in the project root for license information.
-#--------------------------------------------------------------------------
+# encoding: utf-8
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License in the project root for license information.
 require 'log4r'
+require 'vagrant-azure/util/machine_id_helper'
+require 'vagrant-azure/util/vm_await'
+require 'vagrant-azure/util/vm_status_translator'
+require 'vagrant-azure/util/timer'
 
-# Barebones basic implemenation. This a work in progress in very early stages
 module VagrantPlugins
-  module WinAzure
+  module Azure
     module Action
       class StopInstance
+        include VagrantPlugins::Azure::Util::MachineIdHelper
+        include VagrantPlugins::Azure::Util::VMAwait
+        include VagrantPlugins::Azure::Util::VMStatusTranslator
 
         def initialize(app, env)
           @app = app
@@ -17,23 +21,34 @@ module VagrantPlugins
         end
 
         def call(env)
-          if env[:machine].state.id == :StoppedDeallocated
-            env[:ui].info(
-              I18n.t('vagrant_azure.already_status', :status => 'stopped.')
-            )
+          env[:metrics] ||= {}
+
+          parsed = parse_machine_id(env[:machine].id)
+          if env[:machine].state.id == :stopped
+            env[:ui].info(I18n.t('vagrant_azure.already_status', :status => 'stopped.'))
           else
-            env[:machine].id =~ /@/
-            VagrantPlugins::WinAzure::CLOUD_SERVICE_SEMAPHORE.synchronize do
-              env[:ui].info(
-                  I18n.t(
-                      'vagrant_azure.stopping',
-                      :vm_name => $`,
-                      :cloud_service_name => $'
-                  )
-              )
-              env[:azure_vm_service].shutdown_virtual_machine($`, $')
+            env[:ui].info(I18n.t('vagrant_azure.stopping', parsed))
+            env[:azure_arm_service].compute.virtual_machines.power_off(parsed[:group], parsed[:name])
+
+            # Wait for the instance to be ready first
+            env[:metrics]['instance_stop_time'] = Util::Timer.time do
+
+              env[:ui].info(I18n.t('vagrant_azure.waiting_for_stop'))
+
+              task = await_true(env) do |vm|
+                stopped?(vm.properties.instance_view.statuses)
+              end
+
+              if task.value
+                env[:ui].info(I18n.t('vagrant_azure.stopped', parsed))
+              else
+                raise I18n.t('vagrant_azure.errors.failed_starting', parsed) unless env[:interrupted]
+              end
             end
+
+            env[:ui].info(I18n.t('vagrant_azure.stopped', parsed))
           end
+
           @app.call(env)
         end
       end

data/lib/vagrant-azure/action/terminate_instance.rb

@@ -1,30 +1,34 @@
-#--------------------------------------------------------------------------
-# Copyright (c) Microsoft Open Technologies, Inc.
-# All Rights Reserved. Licensed under the Apache 2.0 License.
-#--------------------------------------------------------------------------
+# encoding: utf-8
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License in the project root for license information.
 require 'log4r'
+require 'vagrant-azure/util/machine_id_helper'
 
 module VagrantPlugins
-  module WinAzure
+  module Azure
     module Action
       class TerminateInstance
+        include VagrantPlugins::Azure::Util::MachineIdHelper
+
         def initialize(app, env)
           @app = app
           @logger = Log4r::Logger.new('vagrant_azure::action::terminate_instance')
         end
 
         def call(env)
-          env[:machine].id =~ /@/
-
-          vm = env[:azure_vm_service].get_virtual_machine($`, $')
+          parsed = parse_machine_id(env[:machine].id)
 
-          if vm.nil?
-            # machine not found. assuming it was not created or destroyed
-            env[:ui].info (I18n.t('vagrant_azure.not_created'))
-          else
-            env[:azure_vm_service].delete_virtual_machine($`, $')
-            env[:machine].id = nil
+          begin
+            env[:ui].info(I18n.t('vagrant_azure.terminating', parsed))
+            env[:azure_arm_service].resources.resource_groups.delete(parsed[:group]).value!.body
+          rescue MsRestAzure::AzureOperationError => ex
+            unless ex.response.status == 404
+              raise ex
+            end
           end
+          env[:ui].info(I18n.t('vagrant_azure.terminated', parsed))
+
+          env[:machine].id = nil
 
           @app.call(env)
         end