pax_global_header00006660000000000000000000000064127015605420014514gustar00rootroot0000000000000052 comment=44a3b0b8c67b565e96474a510632b4cb01e1d522 vagrant-azure-2.0.0.pre1/000077500000000000000000000000001270156054200151475ustar00rootroot00000000000000vagrant-azure-2.0.0.pre1/.gitignore000066400000000000000000000003071270156054200171370ustar00rootroot00000000000000id .DS_Store Gemfile.lock azure.box Vagrantfile !example_box/Vagrantfile !example_box/README.md babu example_box/ *.rdp pkg/* gem/ manifests/ modules/ .vagrant/ .idea/ *.pem .ruby-version *.ps1 .env vagrant-azure-2.0.0.pre1/.rspec000066400000000000000000000000361270156054200162630ustar00rootroot00000000000000--color --require spec_helper vagrant-azure-2.0.0.pre1/CHANGELOG.md000066400000000000000000000011571270156054200167640ustar00rootroot00000000000000## 1.0.5 (09 May 2014) FEATURES - Provision for windows VM. - Windows VM has to be specifically mentioned in the Vagrantfile with `config.vm.guest = :windows` - Chef, Puppet and Shell provision for Linux and Windows VM. - **SyncedFolders** - Linux VM uses `rsync` and has be mentioned in the VagrantFile. - Windows VM will default to use PowerShell to copy files. IMPROVEMENTS - Better exception handling when VM fails to get created in cloud. - Better exception handling for WinRM session errors. BUGFIXES - Cleaned up few typo in README - Compatible with Vagrant 1.6 [GH-15] ## Previous See git commits vagrant-azure-2.0.0.pre1/Gemfile000066400000000000000000000010731270156054200164430ustar00rootroot00000000000000# encoding: utf-8 # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License in the project root for license information. source 'https://rubygems.org' gemspec group :development do # We depend on Vagrant for development, but we don't add it as a # gem dependency because we expect to be installed within the # Vagrant environment itself using `vagrant plugin`. gem 'vagrant', git: 'git://github.com/mitchellh/vagrant.git', tag: 'v1.7.4' gem 'dotenv' end group :plugins do gem 'vagrant-azure', path: '.' end vagrant-azure-2.0.0.pre1/LICENSE000066400000000000000000000020641270156054200161560ustar00rootroot00000000000000The MIT License (MIT) Copyright (c) 2015 Microsoft 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. vagrant-azure-2.0.0.pre1/README.md000066400000000000000000000110341270156054200164250ustar00rootroot00000000000000# Vagrant Azure Provider [![Gem Version](https://badge.fury.io/rb/vagrant-azure.png)](https://rubygems.org/gems/vagrant-azure) This is a [Vagrant](http://www.vagrantup.com) 1.7.3+ plugin that adds [Microsoft Azure](https://azure.microsoft.com) provider to Vagrant, allowing Vagrant to control and provision machines in Microsoft Azure. ## Usage Install Vagrant 1.7.3 or higher - [Download Vagrant](http://www.vagrantup.com/downloads.html) Install the vagrant-azure plugin using the standard Vagrant 1.1+ installation methods. After installing the plugin, you can ```vagrant up``` and use ```azure``` provider. For example: ``` C:\> vagrant plugin install vagrant-azure 2.0.0.pre1 ... C:\> vagrant up --provider=azure ... ``` You'll need an ```azure``` box before you can do ```vagrant up``` though. ## Quick Start You can use the dummy box and specify all the required details manually in the ```config.vm.provider``` block in your ```Vagrantfile```. Add the dummy box with the name you want: ``` C:\> vagrant box add azure https://github.com/azure/vagrant-azure/raw/v2.0/dummy.box ... ``` Now edit your ```Vagrantfile``` as shown below and provide all the values as explained. ```ruby Vagrant.configure('2') do |config| config.vm.box = 'azure' # use local ssh key to connect to remote vagrant box config.ssh.private_key_path = '~/.ssh/id_rsa' config.vm.provider :azure do |azure, override| # use Azure Active Directory Application / Service Principal to connect to Azure # see: https://azure.microsoft.com/en-us/documentation/articles/resource-group-create-service-principal-portal/ # each of the below values will default to use the env vars named as below if not specified explicitly azure.tenant_id = ENV['AZURE_TENANT_ID'] azure.client_id = ENV['AZURE_CLIENT_ID'] azure.client_secret = ENV['AZURE_CLIENT_SECRET'] azure.subscription_id = ENV['AZURE_SUBSCRIPTION_ID'] end end ``` Now you can run ``` C:\> vagrant up --provider=azure ``` This will bring up an Azure VM as per the configuration options set above. You can now either SSH (if its a *Nix VM) using ```vagrant ssh```, RDP (if its a Windows VM) using ```vagrant rdp``` or PowerShell ```vagrant powershell```. Normally, a lot of this options, e.g., ```vm_image_urn```, will be embedded in a box file and you just have to provide minimal options in the ```Vagrantfile```. Since, we're using a dummy box, there are no pre-configured defaults. ## Azure Boxes The vagrant-azure plugin provides the ability to use ```Azure``` boxes with Vagrant. Please see the example box provided in [example_box/ directory](https://github.com/azure/vagrant-azure/tree/v2.0/example_box) and follow the instructions there to build an ```azure``` box. Please see [Vagrant Docs](http://docs.vagrantup.com/v2/) for more details. ## Configuration The vagrant-azure provide exposes a few Azure specific configuration options: ### Mandatory For instructions on how to setup an Azure Active Directory Application see: https://azure.microsoft.com/en-us/documentation/articles/resource-group-create-service-principal-portal/ * `tenant_id`: Your Azure Active Directory Tenant Id. * `client_id`: Your Azure Active Directory application client id. * `client_secret`: Your Azure Active Directory application client secret. * `subscription_id`: The Azure subscription Id you'd like to use. ### Optional * `resource_group_name`: (Optional) Name of the resource group to use. * `location`: (Optional) Azure location to build the VM -- defaults to 'westus' * `vm_name`: (Optional) Name of the virtual machine * `vm_password`: (Optional for *nix) Password for the VM -- This is not recommended for *nix deployments * `vm_size`: (Optional) VM size to be used -- defaults to 'Standard_D1'. See: https://azure.microsoft.com/en-us/documentation/articles/virtual-machines-linux-sizes/ * `vm_image_urn`: (Optional) Name of the virtual machine image urn to use -- defaults to 'canonical:ubuntuserver:16.04.0-DAILY-LTS:latest'. See: https://azure.microsoft.com/en-us/documentation/articles/virtual-machines-linux-cli-ps-findimage/ * `virtual_network_name`: (Optional) Name of the virtual network resource * `subnet_name`: (Optional) Name of the virtual network subnet resource * `instance_ready_timeout`: (Optional) The timeout to wait for an instance to become ready -- default 120 seconds. * `instance_check_interval`: (Optional) The interval to wait for checking an instance's state -- default 2 seconds. * `endpoint`: (Optional) The Azure Management API endpoint -- default 'https://management.azure.com' seconds -- ENV['AZURE_MANAGEMENT_ENDPOINT']. vagrant-azure-2.0.0.pre1/Rakefile000066400000000000000000000005161270156054200166160ustar00rootroot00000000000000# 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 'rubygems' require 'bundler/setup' $stdout.sync = true $stderr.sync = true Dir.chdir(File.expand_path('../', __FILE__)) Bundler::GemHelper.install_tasks vagrant-azure-2.0.0.pre1/dummy.box000066400000000000000000000060001270156054200170100ustar00rootroot00000000000000metadata.json000666 000000 000000 00000000035 12316712176 011707 0ustar00000000 000000 { "provider": "azure" } Vagrantfile000666 000000 000000 00000000774 12317176711 011433 0ustar00000000 000000 # -*- mode: ruby -*- # vi: set ft=ruby : # Vagrantfile API/syntax version. Don't touch unless you know what you're doing! VAGRANTFILE_API_VERSION = '2' Vagrant.configure(VAGRANTFILE_API_VERSION) do |config| # All Vagrant configuration is done here. The most common configuration # options are documented and commented below. For a complete reference, # please see the online documentation at vagrantup.com. config.vm.provider :azure do |azure| azure.vm_size = 'Small' end end vagrant-azure-2.0.0.pre1/example_box/000077500000000000000000000000001270156054200174525ustar00rootroot00000000000000vagrant-azure-2.0.0.pre1/example_box/README.md000066400000000000000000000015301270156054200207300ustar00rootroot00000000000000# Vagrant Azure Example Box This directory contains the sample contents of a box for `azure` provider. Build this into a box using: On Windows: ``` C:\> bsdtar -cvzf azure.box metadata.json Vagrantfile ``` On *Nix: ``` $ tar cvzf azure.box ./metadata.json ./Vagrantfile ``` You can add any defaults supported by the ```azure``` provider to the `Vagrantfile` in your box and Vagrant's built-in merging system will set them as defaults. Users can override these defaults in their own Vagrantfiles. You can specify the image to be used for the VM here via the ```vm_image``` option. E.g., ```ruby Vagrant.configure('2') do |config| config.vm.box = 'azure' config.vm.provider :azure do |azure| azure.vm_image = 'NAME OF THE IMAGE TO USE' end end ``` See also: [`Get-AzureVMImage`](http://msdn.microsoft.com/en-us/library/azure/dn495275.aspx) vagrant-azure-2.0.0.pre1/example_box/Vagrantfile000066400000000000000000000006101270156054200216340ustar00rootroot00000000000000# -*- mode: ruby -*- # vi: set ft=ruby : # All Vagrant configuration is done below. The "2" in Vagrant.configure # configures the configuration version (we support older styles for # backwards compatibility). Please don't change it unless you know what # you're doing. Vagrant.configure('2') do |config| config.vm.box = 'azure' config.vm.provider :azure do |azure, override| end end vagrant-azure-2.0.0.pre1/example_box/metadata.json000066400000000000000000000000321270156054200221200ustar00rootroot00000000000000{ "provider": "azure" } vagrant-azure-2.0.0.pre1/lib/000077500000000000000000000000001270156054200157155ustar00rootroot00000000000000vagrant-azure-2.0.0.pre1/lib/vagrant-azure.rb000066400000000000000000000011701270156054200210270ustar00rootroot00000000000000# 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 'pathname' require 'vagrant-azure/plugin' module VagrantPlugins module Azure lib_path = Pathname.new(File.expand_path('../vagrant-azure', __FILE__)) autoload :Action, lib_path.join('action') autoload :Errors, lib_path.join('errors') # This returns the path to the source of this plugin. # # @return [Pathname] def self.source_root @source_root ||= Pathname.new(File.expand_path('../../', __FILE__)) end end end vagrant-azure-2.0.0.pre1/lib/vagrant-azure/000077500000000000000000000000001270156054200205035ustar00rootroot00000000000000vagrant-azure-2.0.0.pre1/lib/vagrant-azure/action.rb000066400000000000000000000136041270156054200223110ustar00rootroot00000000000000# 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 'pathname' require 'vagrant/action/builder' require 'vagrant/action/builtin/wait_for_communicator' module VagrantPlugins module Azure module Action # Include the built-in modules so we can use them as top-level things. include Vagrant::Action::Builtin # This action is called to halt the remote machine. def self.action_halt Vagrant::Action::Builder.new.tap do |b| b.use ConfigValidate b.use Call, IsCreated do |env, b2| unless env[:result] b2.use MessageNotCreated next end b2.use ConnectAzure b2.use StopInstance end end end # This action is called to terminate the remote machine. def self.action_destroy Vagrant::Action::Builder.new.tap do |b| b.use Call, DestroyConfirm do |env, b2| if env[:result] b2.use ConfigValidate b2.use Call, IsCreated do |env2, b3| unless env2[:result] b3.use MessageNotCreated next end b3.use ConnectAzure b3.use TerminateInstance b3.use ProvisionerCleanup if defined?(ProvisionerCleanup) end else b2.use MessageWillNotDestroy end end end end # This action is called when `vagrant provision` is called. def self.action_provision Vagrant::Action::Builder.new.tap do |b| b.use ConfigValidate b.use Call, IsCreated do |env, b2| unless env[:result] b2.use MessageNotCreated next end b2.use Provision end end end # This action is called to read the SSH info of the machine. The # resulting state is expected to be put into the `:machine_ssh_info` key. def self.action_read_ssh_info Vagrant::Action::Builder.new.tap do |b| b.use ConfigValidate b.use ConnectAzure b.use ReadSSHInfo end end # This action is called to read the state of the machine. The # resulting state is expected to be put into the `:machine_state_id` # key. def self.action_read_state Vagrant::Action::Builder.new.tap do |b| b.use ConfigValidate b.use ConnectAzure b.use ReadState end end # This action is called to SSH into the machine. def self.action_ssh Vagrant::Action::Builder.new.tap do |b| b.use ConfigValidate b.use Call, IsCreated do |env, b2| unless env[:result] b2.use MessageNotCreated next end b2.use SSHExec end end end def self.action_ssh_run Vagrant::Action::Builder.new.tap do |b| b.use ConfigValidate b.use Call, IsCreated do |env, b2| unless env[:result] b2.use MessageNotCreated next end b2.use SSHRun end end end def self.action_prepare_boot Vagrant::Action::Builder.new.tap do |b| b.use Provision b.use SyncedFolders end end # This action is called to bring the box up from nothing. def self.action_up Vagrant::Action::Builder.new.tap do |b| b.use HandleBox b.use ConfigValidate b.use BoxCheckOutdated b.use ConnectAzure b.use Call, IsCreated do |env1, b1| if env1[:result] b1.use Call, IsStopped do |env2, b2| if env2[:result] b2.use action_prepare_boot b2.use StartInstance # restart this instance else b2.use MessageAlreadyCreated end end else b1.use action_prepare_boot b1.use RunInstance # launch a new instance end end end end def self.action_reload Vagrant::Action::Builder.new.tap do |b| b.use ConfigValidate b.use ConnectAzure b.use Call, IsCreated do |env, b2| unless env[:result] b2.use MessageNotCreated next end b2.use action_halt b2.use Call, WaitForState, :stopped, 120 do |env2, b3| if env2[:result] b3.use action_up else # ??? it didn't stop end end end end end # The autoload farm action_root = Pathname.new(File.expand_path('../action', __FILE__)) autoload :ConnectAzure, action_root.join('connect_azure') autoload :IsCreated, action_root.join('is_created') autoload :IsStopped, action_root.join('is_stopped') autoload :MessageAlreadyCreated, action_root.join('message_already_created') autoload :MessageNotCreated, action_root.join('message_not_created') autoload :MessageWillNotDestroy, action_root.join('message_will_not_destroy') autoload :ReadSSHInfo, action_root.join('read_ssh_info') autoload :ReadState, action_root.join('read_state') autoload :RestartVM, action_root.join('restart_vm') autoload :RunInstance, action_root.join('run_instance') autoload :StartInstance, action_root.join('start_instance') autoload :StopInstance, action_root.join('stop_instance') autoload :TerminateInstance, action_root.join('terminate_instance') autoload :TimedProvision, action_root.join('timed_provision') autoload :WaitForState, action_root.join('wait_for_state') end end end vagrant-azure-2.0.0.pre1/lib/vagrant-azure/action/000077500000000000000000000000001270156054200217605ustar00rootroot00000000000000vagrant-azure-2.0.0.pre1/lib/vagrant-azure/action/connect_azure.rb000066400000000000000000000016221270156054200251450ustar00rootroot00000000000000# 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_relative '../services/azure_resource_manager' require 'log4r' module VagrantPlugins module Azure module Action class ConnectAzure def initialize(app, env) @app = app @logger = Log4r::Logger.new('vagrant_azure::action::connect_azure') end def call (env) if env[:azure_arm_service].nil? config = env[:machine].provider_config provider = MsRestAzure::ApplicationTokenProvider.new(config.tenant_id, config.client_id, config.client_secret) env[:azure_arm_service] = VagrantPlugins::Azure::Services::AzureResourceManager.new(provider, config.subscription_id) end @app.call(env) end end end end end vagrant-azure-2.0.0.pre1/lib/vagrant-azure/action/is_created.rb000066400000000000000000000007171270156054200244140ustar00rootroot00000000000000# encoding: utf-8 # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License in the project root for license information. module VagrantPlugins module Azure module Action class IsCreated def initialize(app, env) @app = app end def call(env) env[:result] = env[:machine].state.id != :not_created @app.call(env) end end end end endvagrant-azure-2.0.0.pre1/lib/vagrant-azure/action/is_stopped.rb000066400000000000000000000007131270156054200244570ustar00rootroot00000000000000# encoding: utf-8 # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License in the project root for license information. module VagrantPlugins module Azure module Action class IsStopped def initialize(app, env) @app = app end def call(env) env[:result] = env[:machine].state.id == :stopped @app.call(env) end end end end endvagrant-azure-2.0.0.pre1/lib/vagrant-azure/action/message_already_created.rb000066400000000000000000000007611270156054200271250ustar00rootroot00000000000000# encoding: utf-8 # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License in the project root for license information. module VagrantPlugins module Azure module Action class MessageAlreadyCreated def initialize(app, env) @app = app end def call(env) env[:ui].info(I18n.t('vagrant_azure.already_status', :status => 'created')) @app.call(env) end end end end endvagrant-azure-2.0.0.pre1/lib/vagrant-azure/action/message_not_created.rb000066400000000000000000000007241270156054200263030ustar00rootroot00000000000000# encoding: utf-8 # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License in the project root for license information. module VagrantPlugins module Azure module Action class MessageNotCreated def initialize(app, env) @app = app end def call(env) env[:ui].info(I18n.t('vagrant_azure.not_created')) @app.call(env) end end end end endvagrant-azure-2.0.0.pre1/lib/vagrant-azure/action/message_will_not_destroy.rb000066400000000000000000000007671270156054200274230ustar00rootroot00000000000000# encoding: utf-8 # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License in the project root for license information. module VagrantPlugins module Azure module Action class MessageWillNotDestroy def initialize(app, env) @app = app end def call(env) env[:ui].info(I18n.t('vagrant_azure.will_not_destroy', name: env[:machine].name)) @app.call(env) end end end end endvagrant-azure-2.0.0.pre1/lib/vagrant-azure/action/read_ssh_info.rb000066400000000000000000000020531270156054200251100ustar00rootroot00000000000000# 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 Azure module Action class ReadSSHInfo include VagrantPlugins::Azure::Util::MachineIdHelper def initialize(app, env, port = 22) @app = app @port = port @logger = Log4r::Logger.new('vagrant_azure::action::read_ssh_info') end def call(env) env[:machine_ssh_info] = read_ssh_info(env[:azure_arm_service], env) @app.call(env) end def read_ssh_info(azure, env) return nil if env[:machine].id.nil? parsed = parse_machine_id(env[:machine].id) public_ip = azure.network.public_ipaddresses.get(parsed[:group], "#{parsed[:name]}-vagrantPublicIP").value!.body {:host => public_ip.properties.dns_settings.fqdn, :port => 22} end end end end end vagrant-azure-2.0.0.pre1/lib/vagrant-azure/action/read_state.rb000066400000000000000000000030531270156054200244210ustar00rootroot00000000000000# 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 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[:azure_arm_service], env[:machine]) @app.call(env) end 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 # Return the state power_state(vm.properties.instance_view.statuses) end end end end end vagrant-azure-2.0.0.pre1/lib/vagrant-azure/action/restart_vm.rb000066400000000000000000000015701270156054200244760ustar00rootroot00000000000000# 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 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) 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 end end end vagrant-azure-2.0.0.pre1/lib/vagrant-azure/action/run_instance.rb000066400000000000000000000206101270156054200247740ustar00rootroot00000000000000# 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_mgmt_resources' require 'vagrant/util/template_renderer' require 'vagrant-azure/util/timer' require 'vagrant-azure/util/machine_id_helper' require 'haikunator' module VagrantPlugins module Azure module Action class RunInstance include Vagrant::Util::Retryable include VagrantPlugins::Azure::Util::MachineIdHelper def initialize(app, env) @app = app @logger = Log4r::Logger.new('vagrant_azure::action::run_instance') end def call(env) # 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 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 template_params = { operating_system: get_image_os(image_details) } 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']}") deployment_params = build_deployment_params(template_params, deployment_params.reject{|_,v| v.nil?}) env[:ui].info('Starting deployment') env[:metrics]['deployment_time'] = Util::Timer.time do put_deployment(azure, resource_group_name, deployment_params) end 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 @logger.info("Time for SSH ready: #{env[:metrics]['instance_ssh_time']}") # Ready and booted! env[:ui].info(I18n.t('vagrant_azure.ready')) end # 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 def put_deployment(azure, rg_name, params) azure.resources.deployments.create_or_update(rg_name, 'vagrant', params).value!.body end def put_resource_group(azure, name, location) params = ::Azure::ARM::Resources::Models::ResourceGroup.new.tap do |rg| rg.location = location end azure.resources.resource_groups.create_or_update(name, params).value!.body end # 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 end end vagrant-azure-2.0.0.pre1/lib/vagrant-azure/action/start_instance.rb000066400000000000000000000033261270156054200253320ustar00rootroot00000000000000# 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' module VagrantPlugins 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') end def call(env) 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 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 end end end vagrant-azure-2.0.0.pre1/lib/vagrant-azure/action/stop_instance.rb000066400000000000000000000035741270156054200251670ustar00rootroot00000000000000# 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' module VagrantPlugins 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 @logger = Log4r::Logger.new('vagrant_azure::action::stop_instance') end def call(env) 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[: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 end end end vagrant-azure-2.0.0.pre1/lib/vagrant-azure/action/terminate_instance.rb000066400000000000000000000021311270156054200261560ustar00rootroot00000000000000# 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 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) parsed = parse_machine_id(env[:machine].id) 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 end end end end vagrant-azure-2.0.0.pre1/lib/vagrant-azure/action/wait_for_state.rb000066400000000000000000000025601270156054200253220ustar00rootroot00000000000000# 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 'timeout' module VagrantPlugins module Azure module Action class WaitForState # env[:result] will be false in case of timeout. # @param [Symbol] state Target machine state. # @param [Number] timeout Timeout in seconds. # @param [Object] env vagrant environment def initialize(app, env, state, timeout) @app = app @logger = Log4r::Logger.new('vagrant_azure::action::wait_for_state') @state = state @timeout = timeout @env = env end def call(env) env[:result] = true if env[:machine].state.id == @state @logger.info(I18n.t('vagrant_azure.already_status', :status => @state)) else @logger.info("Waiting for machine to reach state #{@state}") begin Timeout.timeout(@timeout) do until env[:machine].state.id == @state sleep 2 end end rescue Timeout::Error env[:result] = false # couldn't reach state in time end end @app.call(env) end end end end end vagrant-azure-2.0.0.pre1/lib/vagrant-azure/config.rb000066400000000000000000000126041270156054200223000ustar00rootroot00000000000000# 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 'vagrant' require 'haikunator' module VagrantPlugins module Azure class Config < Vagrant.plugin('2', :config) # The Azure Active Directory Tenant ID -- ENV['AZURE_TENANT_ID'] # # @return [String] attr_accessor :tenant_id # The Azure Active Directory Application Client ID -- ENV['AZURE_CLIENT_ID'] # # @return [String] attr_accessor :client_id # The Azure Active Directory Application Client Secret -- ENV['AZURE_CLIENT_SECRET'] # # @return [String] attr_accessor :client_secret # The Azure Subscription ID to use -- ENV['AZURE_SUBSCRIPTION_ID'] # # @return [String] attr_accessor :subscription_id # (Optional) Name of the resource group to use. # # @return [String] attr_accessor :resource_group_name # (Optional) Azure location to build the VM -- defaults to 'westus' # # @return [String] attr_accessor :location # (Optional) Name of the virtual machine # # @return [String] attr_accessor :vm_name # Password for the VM -- This is not recommended for *nix deployments # # @return [String] attr_accessor :vm_password # (Optional) VM size to be used -- defaults to 'Standard_D1'. See: https://azure.microsoft.com/en-us/documentation/articles/virtual-machines-linux-sizes/ # # @return [String] attr_accessor :vm_size # (Optional) Name of the virtual machine image urn to use -- defaults to 'canonical:ubuntuserver:16.04.0-DAILY-LTS:latest'. See: https://azure.microsoft.com/en-us/documentation/articles/virtual-machines-linux-cli-ps-findimage/ # # @return [String] attr_accessor :vm_image_urn # (Optional) Name of the virtual network resource # # @return [String] attr_accessor :virtual_network_name # (Optional) Name of the virtual network subnet resource # # @return [String] attr_accessor :subnet_name # (Optional) TCP endpoints to open up for the VM # # @return [String] attr_accessor :tcp_endpoints # (Optional) Name of the virtual machine image # # @return [String] attr_accessor :availability_set_name # (Optional) The timeout to wait for an instance to become ready -- default 120 seconds. # # @return [Fixnum] attr_accessor :instance_ready_timeout # (Optional) The interval to wait for checking an instance's state -- default 2 seconds. # # @return [Fixnum] attr_accessor :instance_check_interval # (Optional) The Azure Management API endpoint -- default 'https://management.azure.com' seconds -- ENV['AZURE_MANAGEMENT_ENDPOINT']. # # @return [String] attr_accessor :endpoint def initialize @tenant_id = UNSET_VALUE @client_id = UNSET_VALUE @client_secret = UNSET_VALUE @endpoint = UNSET_VALUE @subscription_id = UNSET_VALUE @resource_group_name = UNSET_VALUE @location = UNSET_VALUE @vm_name = UNSET_VALUE @vm_password = UNSET_VALUE @vm_image_urn = UNSET_VALUE @virtual_network_name = UNSET_VALUE @subnet_name = UNSET_VALUE @tcp_endpoints = UNSET_VALUE @vm_size = UNSET_VALUE @availability_set_name = UNSET_VALUE @instance_ready_timeout = UNSET_VALUE @instance_check_interval = UNSET_VALUE end def finalize! @endpoint = (ENV['AZURE_MANAGEMENT_ENDPOINT'] || 'https://management.azure.com') if @endpoint == UNSET_VALUE @subscription_id = ENV['AZURE_SUBSCRIPTION_ID'] if @subscription_id == UNSET_VALUE @tenant_id = ENV['AZURE_TENANT_ID'] if @tenant_id == UNSET_VALUE @client_id = ENV['AZURE_CLIENT_ID'] if @client_id == UNSET_VALUE @client_secret = ENV['AZURE_CLIENT_SECRET'] if @client_secret == UNSET_VALUE @vm_name = Haikunator.haikunate(100) if @vm_name == UNSET_VALUE @resource_group_name = Haikunator.haikunate(100) if @resource_group_name == UNSET_VALUE @vm_password = nil if @vm_password == UNSET_VALUE @vm_image_urn = 'canonical:ubuntuserver:16.04.0-DAILY-LTS:latest' if @vm_image_urn == UNSET_VALUE @location = 'westus' if @location == UNSET_VALUE @virtual_network_name = nil if @virtual_network_name == UNSET_VALUE @subnet_name = nil if @subnet_name == UNSET_VALUE @tcp_endpoints = nil if @tcp_endpoints == UNSET_VALUE @vm_size = 'Standard_D1' if @vm_size == UNSET_VALUE @availability_set_name = nil if @availability_set_name == UNSET_VALUE @instance_ready_timeout = 120 if @instance_ready_timeout == UNSET_VALUE @instance_check_interval = 2 if @instance_check_interval == UNSET_VALUE end def validate(machine) errors = _detected_errors # Azure connection properties related validation. errors << I18n.t('vagrant_azure.subscription_id.required') if @subscription_id.nil? errors << I18n.t('vagrant_azure.mgmt_endpoint.required') if @endpoint.nil? errors << I18n.t('vagrant_azure.auth.required') if @tenant_id.nil? || @client_secret.nil? || @client_id.nil? { 'Microsoft Azure Provider' => errors } end end end end vagrant-azure-2.0.0.pre1/lib/vagrant-azure/errors.rb000066400000000000000000000011621270156054200223440ustar00rootroot00000000000000# encoding: utf-8 # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License in the project root for license information. module VagrantPlugins module Azure module Errors class AzureError < Vagrant::Errors::VagrantError error_namespace('vagrant_azure.errors') end class WinRMNotReady < AzureError error_key(:win_rm_not_ready) end class ServerNotCreated < AzureError error_key(:server_not_created) end class CreateVMFailure < AzureError error_key(:create_vm_failure) end end end end vagrant-azure-2.0.0.pre1/lib/vagrant-azure/plugin.rb000066400000000000000000000045521270156054200223340ustar00rootroot00000000000000# encoding: utf-8 # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License in the project root for license information. begin require 'vagrant' rescue LoadError raise 'The Vagrant Azure plugin must be run within Vagrant.' end # This is a sanity check to make sure no one is attempting to install this into # an early Vagrant version. if Vagrant::VERSION < '1.6.0' raise 'The Vagrant Azure plugin is only compatible with Vagrant 1.6+' end module VagrantPlugins module Azure class Plugin < Vagrant.plugin('2') name 'Azure' description <<-DESC This plugin installs a provider that allows Vagrant to manage machines in Microsoft Azure. DESC config(:azure, :provider) do require_relative 'config' Config end provider(:azure, parallel: true) do # Setup logging and i18n setup_logging setup_i18n # Return the provider require_relative 'provider' Provider end def self.setup_i18n I18n.load_path << File.expand_path( 'locales/en.yml', Azure.source_root ) I18n.load_path << File.expand_path( 'templates/locales/en.yml', Vagrant.source_root ) I18n.load_path << File.expand_path( 'templates/locales/providers_hyperv.yml', Vagrant.source_root ) I18n.reload! end def self.setup_logging require 'log4r' level = nil begin level = Log4r.const_get(ENV['VAGRANT_LOG'].upcase) rescue NameError # This means that the logging constant wasn't found, # which is fine. We just keep `level` as `nil`. But # we tell the user. level = nil end # Some constants, such as "true" resolve to booleans, so the # above error checking doesn't catch it. This will check to make # sure that the log level is an integer, as Log4r requires. level = nil if !level.is_a?(Integer) # Set the logging level on all "vagrant" namespaced logs as long as # we have a valid level if level logger = Log4r::Logger.new('vagrant_azure') logger.outputters = Log4r::Outputter.stderr logger.level = level logger = nil end end end end end vagrant-azure-2.0.0.pre1/lib/vagrant-azure/provider.rb000066400000000000000000000031571270156054200226700ustar00rootroot00000000000000# 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' module VagrantPlugins module Azure class Provider < Vagrant.plugin('2', :provider) def initialize(machine) @machine = machine end def action(name) # Attempt to get the action method from the Action class if it # exists, otherwise return nil to show that we don't support the # given action. action_method = "action_#{name}" return Action.send(action_method) if Action.respond_to?(action_method) nil end def ssh_info # Run a custom action called "read_ssh_info" which does what it # says and puts the resulting SSH info into the `:machine_ssh_info` # key in the environment. env = @machine.action('read_ssh_info') env[:machine_ssh_info] end def state # Run a custom action we define called "read_state" which does what it # says. It puts the state in the `:machine_state_id` key in the env env = @machine.action('read_state') state_id = env[:machine_state_id] # Get the short and long description short = I18n.t("vagrant_azure.states.short_#{state_id}") long = I18n.t("vagrant_azure.states.long_#{state_id}") # Return the MachineState object Vagrant::MachineState.new(state_id, short, long) end def to_s id = @machine.id.nil? ? 'new' : @machine.id "Azure (#{id})" end end end end vagrant-azure-2.0.0.pre1/lib/vagrant-azure/services/000077500000000000000000000000001270156054200223265ustar00rootroot00000000000000vagrant-azure-2.0.0.pre1/lib/vagrant-azure/services/azure_resource_manager.rb000066400000000000000000000057511270156054200274120ustar00rootroot00000000000000# 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 'azure_mgmt_resources' require 'azure_mgmt_compute' require 'azure_mgmt_network' require 'azure_mgmt_storage' module VagrantPlugins module Azure module Services class AzureResourceManager TENANT_ID_NAME = 'AZURE_TENANT_ID' CLIENT_ID_NAME = 'AZURE_CLIENT_ID' CLIENT_SECRET_NAME = 'AZURE_CLIENT_SECRET' # AzureResourceManager provides access to the Azure Resource Manager APIs # @param [MsRest::TokenProvider] token_provider object used to procure an authentication token from Azure Active # Directory # @param [String] subscription_id # @param [String] base_url def initialize(token_provider, subscription_id, base_url = nil) @token_provider = if token_provider.nil? || !token_provider.is_a?(MsRest::TokenProvider) if ENV[TENANT_ID_NAME].nil? || ENV[CLIENT_ID_NAME].nil? || ENV[CLIENT_SECRET_NAME].nil? raise ArgumentError "Either set #{TENANT_ID_NAME}, #{CLIENT_ID_NAME} or #{CLIENT_SECRET_NAME} in your environment, or pass in a MsRest::TokenProvider" else MsRestAzure::ApplicationTokenProvider.new( ENV[TENANT_ID_NAME], ENV[CLIENT_ID_NAME], ENV[CLIENT_SECRET_NAME]) end else token_provider end @credential = MsRest::TokenCredentials.new(token_provider) @base_url = base_url @subscription_id = subscription_id end # Azure Resource Manager Compute API Client # @return [Azure::ARM::Compute::ComputeManagementClient] def compute build(::Azure::ARM::Compute::ComputeManagementClient) end # Azure Resource Manager Generic Resource API Client # @return [Azure::ARM::Resources::ResourceManagementClient] def resources build(::Azure::ARM::Resources::ResourceManagementClient) end # Azure Resource Manager Network API Client # @return [Azure::ARM::Network::NetworkManagementClient] def network build(::Azure::ARM::Network::NetworkManagementClient) end # Azure Resource Manager Storage API Client # @return [Azure::ARM::Storage::StorageManagementClient] def storage build(::Azure::ARM::Storage::StorageManagementClient) end private def build(clazz) instance = clazz.new(*client_params) instance.subscription_id = @subscription_id instance end def client_params [@credential, @base_url].reject{ |i| i.nil? } end end end end end vagrant-azure-2.0.0.pre1/lib/vagrant-azure/util/000077500000000000000000000000001270156054200214605ustar00rootroot00000000000000vagrant-azure-2.0.0.pre1/lib/vagrant-azure/util/machine_id_helper.rb000066400000000000000000000006721270156054200254310ustar00rootroot00000000000000module VagrantPlugins module Azure module Util module MachineIdHelper def parse_machine_id(id) parts = id.split(':') { group: parts[0], name: parts[1], location: parts[2] } end def serialize_machine_id(resource_group, vm_name, location) [resource_group, vm_name, location].join(':') end end end end end vagrant-azure-2.0.0.pre1/lib/vagrant-azure/util/timer.rb000066400000000000000000000003751270156054200231320ustar00rootroot00000000000000module VagrantPlugins module Azure module Util class Timer def self.time start_time = Time.now.to_f yield end_time = Time.now.to_f end_time - start_time end end end end endvagrant-azure-2.0.0.pre1/lib/vagrant-azure/util/vm_await.rb000066400000000000000000000016211270156054200236140ustar00rootroot00000000000000module VagrantPlugins module Azure module Util module VMAwait def await_true(env) config = env[:machine].provider_config parsed = parse_machine_id(env[:machine].id) azure = env[:azure_arm_service] tries = config.instance_ready_timeout / 2 count = 0 task = Concurrent::TimerTask.new(execution_interval: config.instance_check_interval ) do task.shutdown if env[:interrupted] if count > tries task.shutdown false end count += 1 vm = azure.compute.virtual_machines.get(parsed[:group], parsed[:name], 'instanceView').value!.body if yield(vm) task.shutdown true end end task.execute task.wait_for_termination task end end end end end vagrant-azure-2.0.0.pre1/lib/vagrant-azure/util/vm_status_translator.rb000066400000000000000000000032141270156054200263030ustar00rootroot00000000000000module VagrantPlugins module Azure module Util module VMStatusTranslator PROVISIONING_STATES = [:provisioned, :deleting] POWER_STATES = [:running, :starting, :deallocating, :deallocated] def vm_status_to_state(status) code = status.code case when code == 'ProvisioningState/succeeded' :provisioned when code == 'ProvisioningState/deleting' :deleting when code == 'PowerState/running' :running when code == 'PowerState/stopping' :stopping when code == 'PowerState/stopped' :stopped when code == 'PowerState/starting' :starting when code == 'PowerState/deallocating' :deallocating when code == 'PowerState/deallocated' :deallocated else :unknown end end def power_state(statuses) vm_status_to_state(statuses.select{ |s| s.code.match(/PowerState/) }.last) end def running?(statuses) statuses.any?{ |s| vm_status_to_state(s) == :running } end def built?(statuses) statuses.any?{ |s| vm_status_to_state(s) == :provisioned } end def stopped?(statuses) statuses.any?{ |s| vm_status_to_state(s) == :stopped } end def stopping?(statuses) statuses.any?{ |s| vm_status_to_state(s) == :stopping } end def tearing_down?(statuses) statuses.any?{ |s| vm_status_to_state(s) == :deleting } end end end end endvagrant-azure-2.0.0.pre1/lib/vagrant-azure/version.rb000066400000000000000000000003641270156054200225200ustar00rootroot00000000000000# encoding: utf-8 # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License in the project root for license information. module VagrantPlugins module Azure VERSION = '2.0.0.pre1' end end vagrant-azure-2.0.0.pre1/locales/000077500000000000000000000000001270156054200165715ustar00rootroot00000000000000vagrant-azure-2.0.0.pre1/locales/en.yml000066400000000000000000000077601270156054200177300ustar00rootroot00000000000000en: vagrant_azure: launching_instance: |- Launching an instance with the following settings... not_created: |- The machine does not exist. Please run `vagrant up` first. will_not_destroy: |- The machine '%{name}' will not be destroyed as the user declined confirmation. already_status: |- The machine is already %{status}. stopping: |- Stopping '%{name}' in '%{group}' terminating: |- Terminating '%{name}' terminated: |- Terminated '%{name}' rdp_not_ready: |- RDP not ready starting: |- VM '%{name}' is starting started: |- VM '%{name}' has been started stopping: |- VM '%{name}' is stopping stopped: |- VM '%{name}' has been stopped restarting: |- VM '%{name}' is restarting restarted: |- VM '%{name}' has been restarted copy_folder: |- Copying folder: %{hostpath} ==> %{guestpath} rsync_not_found_warning: |- Warning! Folder sync disabled because the rsync binary is missing in the %{side}. Make sure rsync is installed and the binary can be found in the PATH. waiting_for_comm: |- Waiting for Communication comm_ready: |- Communication is Ready read_attempt: |- Failed to connect to Virtual Machine. Re-Connecting %{attempt} errors: win_rm_not_ready: |- Vagrant failed to communicate to the VM using powershell. The operation failed with the following message. %{message} server_not_created: |- Server not created. Error is: %{message} create_vm_failure: |- There was some error in creating the VM. failed_starting: |- Failed to start VM '%{name}'!! failed_stopping: |- Failed to stopping VM '%{name}'!! subscription_id: required: |- You must provide an Azure Subscription Id either through ENV['AZURE_SUBSCRIPTION_ID'] or via Vagrantfile. mgmt_endpoint: required: |- You must provide a non-nil Azure Management Endpoint either through ENV['AZURE_MANAGEMENT_ENDPOINT'] or via Vagrantfile. auth: required: |- You must provide Azure Active Directory Tenant ID, Application Client ID and Application Client Secret via ENV or Vagrantfile. states: short_not_created: |- not created long_not_created: |- The Azure instance is not created. Run `vagrant up` to create it. short_stopped: |- stopped long_stopped: |- The Azure instance is stopped. Run `vagrant up` to start it. short_stopping: |- stopping long_stopping: |- The Azure instance is stopping. Wait until is completely stopped to run `vagrant up` and start it. short_pending: |- pending long_pending: |- The Azure instance is pending a start (i.e. this is a transition state). short_running: |- running long_running: |- The Azure instance is running. To stop this machine, you can run `vagrant halt`. To destroy the machine, you can run `vagrant destroy`. short_pending: |- pending long_pending: |- The Azure instance is still being initialized. To destroy this machine, you can run `vagrant destroy`. waiting_for_ssh: |- Waiting for SSH to become available... ready: |- Machine is booted and ready for use! public_key_path_private_key: |- We expect the public key to be added to the Azure VM to be located at the same place as the config.ssh.private_key_path + '.pub'. We couldn't find any public keys for these private key paths: private_key_not_specified: |- Please specify a secure key to use with config.ssh.private_key_path (see: https://www.vagrantup.com/docs/vagrantfile/ssh_settings.html). If not, you publicly accessible Azure VM will be extremely insecure. waiting_for_ready: |- Waiting for instance to become "ready"... waiting_for_stop: |- Waiting for instance to become "stopped"... vagrant-azure-2.0.0.pre1/spec/000077500000000000000000000000001270156054200161015ustar00rootroot00000000000000vagrant-azure-2.0.0.pre1/spec/spec_helper.rb000066400000000000000000000021031270156054200207130ustar00rootroot00000000000000# 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 'vagrant-azure' if ENV['COVERAGE'] || ENV['CI'] || ENV['TRAVIS'] require 'simplecov' require 'coveralls' if ENV['TRAVIS'] SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[ SimpleCov::Formatter::HTMLFormatter, Coveralls::SimpleCov::Formatter ] else SimpleCov.formatter = SimpleCov::Formatter::HTMLFormatter end SimpleCov.start do project_name 'vagrant-azure' add_filter '/build-tests/' add_filter '/coverage/' add_filter '/locales/' add_filter '/templates/' add_filter '/doc/' add_filter '/example_box/' add_filter '/pkg/' add_filter '/spec/' add_filter '/tasks/' add_filter '/yard-template/' add_filter '/yardoc/' end end # import all the support files Dir[File.join(File.dirname(__FILE__), 'support/**/*.rb')].each { |f| require File.expand_path(f) } RSpec.configure do |config| config.order = 'random' endvagrant-azure-2.0.0.pre1/spec/vagrant-azure/000077500000000000000000000000001270156054200206675ustar00rootroot00000000000000vagrant-azure-2.0.0.pre1/spec/vagrant-azure/config_spec.rb000066400000000000000000000005231270156054200234730ustar00rootroot00000000000000# 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 'vagrant' require 'vagrant-azure/config' module VagrantPlugins module Azure describe Config do it 'should config' do end end end end vagrant-azure-2.0.0.pre1/spec/vagrant-azure/services/000077500000000000000000000000001270156054200225125ustar00rootroot00000000000000vagrant-azure-2.0.0.pre1/spec/vagrant-azure/services/azure_resource_manager_spec.rb000066400000000000000000000006231270156054200306010ustar00rootroot00000000000000# 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 'vagrant-azure/services/azure_resource_manager' module VagrantPlugins module Azure module Services describe AzureResourceManager do it 'should be hello world' do end end end end endvagrant-azure-2.0.0.pre1/templates/000077500000000000000000000000001270156054200171455ustar00rootroot00000000000000vagrant-azure-2.0.0.pre1/templates/arm/000077500000000000000000000000001270156054200177245ustar00rootroot00000000000000vagrant-azure-2.0.0.pre1/templates/arm/deployment.json.erb000066400000000000000000000202711270156054200235500ustar00rootroot00000000000000{ "$schema": "http://schema.management.azure.com/schemas/2014-04-01-preview/deploymentTemplate.json", "contentVersion": "1.0.0.0", "parameters": { "adminUserName": { "type": "string", "defaultValue": "vagrant", "metadata": { "description": "User name for the Virtual Machine." } }, <% if operating_system == 'Windows' %> "adminPassword": { "type": "string", "metadata": { "description": "Password for the Virtual Machine (only used on Windows)" } }, <% end %> "sshKeyData": { "type": "string", "metadata": { "description": "SSH rsa public key file as a string." } }, "dnsLabelPrefix": { "type": "string", "metadata": { "description": "Unique DNS Name for the Public IP used to access the Virtual Machine." } }, "vmSize": { "type": "string", "defaultValue": "Standard_D1", "metadata": { "description": "Size of the VM" } }, "vmName": { "type": "string", "metadata": { "description": "Name of the VM" } }, "imagePublisher": { "type": "string", "defaultValue": "canonical", "metadata": { "description": "Name of the image publisher" } }, "imageOffer": { "type": "string", "defaultValue": "ubuntuserver", "metadata": { "description": "Name of the image offer" } }, "imageSku": { "type": "string", "defaultValue": "16.04.0-DAILY-LTS", "metadata": { "description": "Name of the image sku" } }, "imageVersion": { "type": "string", "defaultValue": "latest", "metadata": { "description": "Name of the image sku" } }, "subnetName": { "type": "string", "defaultValue": "vagrant-subnet", "metadata": { "description": "Name of the subnet" } }, "virtualNetworkName": { "type": "string", "defaultValue": "vagrantVNET", "metadata": { "description": "Name of the virtual network" } } }, "variables": { "storageAccountName": "[concat(uniquestring(resourceGroup().id), 'vagrant')]", "location": "[resourceGroup().location]", "osDiskName": "osDisk1", "addressPrefix": "10.0.0.0/16", "subnetPrefix": "10.0.0.0/24", "vmStorageAccountContainerName": "vagrant-vhds", "nicName": "[concat(parameters('vmName'), '-vagrantNIC')]", "publicIPAddressName": "[concat(parameters('vmName'), '-vagrantPublicIP')]", "publicIPAddressType": "Dynamic", "storageAccountType": "Standard_LRS", "networkSecurityGroupName": "[concat(parameters('vmName'), '-vagrantNSG')]", "sshKeyPath": "[concat('/home/',parameters('adminUsername'),'/.ssh/authorized_keys')]", "vnetID": "[resourceId('Microsoft.Network/virtualNetworks', parameters('virtualNetworkName'))]", "subnetRef": "[concat(variables('vnetID'),'/subnets/',parameters('subnetName'))]", "apiVersion": "2015-06-15" }, "resources": [ { "type": "Microsoft.Storage/storageAccounts", "name": "[variables('storageAccountName')]", "apiVersion": "[variables('apiVersion')]", "location": "[variables('location')]", "properties": { "accountType": "[variables('storageAccountType')]" } }, { "apiVersion": "[variables('apiVersion')]", "type": "Microsoft.Network/networkSecurityGroups", "name": "[variables('networkSecurityGroupName')]", "location": "[variables('location')]", "properties": { "securityRules": [ { "name": "ssh_rule", "properties": { "description": "Locks inbound down to ssh default port 22.", "protocol": "Tcp", "sourcePortRange": "*", "destinationPortRange": "22", "sourceAddressPrefix": "*", "destinationAddressPrefix": "*", "access": "Allow", "priority": 123, "direction": "Inbound" } } ] } }, { "apiVersion": "[variables('apiVersion')]", "type": "Microsoft.Network/publicIPAddresses", "name": "[variables('publicIPAddressName')]", "location": "[variables('location')]", "properties": { "publicIPAllocationMethod": "[variables('publicIPAddressType')]", "dnsSettings": { "domainNameLabel": "[parameters('dnsLabelPrefix')]" } } }, { "apiVersion": "[variables('apiVersion')]", "type": "Microsoft.Network/virtualNetworks", "name": "[parameters('virtualNetworkName')]", "location": "[variables('location')]", "dependsOn": [ "[concat('Microsoft.Network/networkSecurityGroups/', variables('networkSecurityGroupName'))]" ], "properties": { "addressSpace": { "addressPrefixes": [ "[variables('addressPrefix')]" ] }, "subnets": [ { "name": "[parameters('subnetName')]", "properties": { "addressPrefix": "[variables('subnetPrefix')]", "networkSecurityGroup": { "id": "[resourceId('Microsoft.Network/networkSecurityGroups', variables('networkSecurityGroupName'))]" } } } ] } }, { "apiVersion": "[variables('apiVersion')]", "type": "Microsoft.Network/networkInterfaces", "name": "[variables('nicName')]", "location": "[variables('location')]", "dependsOn": [ "[concat('Microsoft.Network/publicIPAddresses/', variables('publicIPAddressName'))]", "[concat('Microsoft.Network/virtualNetworks/', parameters('virtualNetworkName'))]" ], "properties": { "ipConfigurations": [ { "name": "ipconfig1", "properties": { "privateIPAllocationMethod": "Dynamic", "publicIPAddress": { "id": "[resourceId('Microsoft.Network/publicIPAddresses', variables('publicIPAddressName'))]" }, "subnet": { "id": "[variables('subnetRef')]" } } } ] } }, { "apiVersion": "[variables('apiVersion')]", "type": "Microsoft.Compute/virtualMachines", "name": "[parameters('vmName')]", "location": "[variables('location')]", "dependsOn": [ "[concat('Microsoft.Storage/storageAccounts/', variables('storageAccountName'))]", "[concat('Microsoft.Network/networkInterfaces/', variables('nicName'))]" ], "properties": { "hardwareProfile": { "vmSize": "[parameters('vmSize')]" }, "osProfile": { "computerName": "[parameters('vmName')]", "adminUsername": "[parameters('adminUsername')]", "linuxConfiguration": { "disablePasswordAuthentication": "true", "ssh": { "publicKeys": [ { "path": "[variables('sshKeyPath')]", "keyData": "[parameters('sshKeyData')]" } ] } } }, "storageProfile": { "imageReference": { "publisher": "[parameters('imagePublisher')]", "offer": "[parameters('imageOffer')]", "sku": "[parameters('imageSku')]", "version": "latest" }, "osDisk": { "name": "osdisk", "vhd": { "uri": "[concat('http://',variables('storageAccountName'),'.blob.core.windows.net/',variables('vmStorageAccountContainerName'),'/', variables('osDiskName'),'.vhd')]" }, "caching": "ReadWrite", "createOption": "FromImage" } }, "networkProfile": { "networkInterfaces": [ { "id": "[resourceId('Microsoft.Network/networkInterfaces', variables('nicName'))]" } ] }, "diagnosticsProfile": { "bootDiagnostics": { "enabled": "true", "storageUri": "[concat('http://',variables('storageAccountName'),'.blob.core.windows.net')]" } } } } ] }vagrant-azure-2.0.0.pre1/templates/provisioners/000077500000000000000000000000001270156054200217075ustar00rootroot00000000000000vagrant-azure-2.0.0.pre1/templates/provisioners/chef-solo/000077500000000000000000000000001270156054200235665ustar00rootroot00000000000000vagrant-azure-2.0.0.pre1/templates/provisioners/chef-solo/solo.erb000066400000000000000000000024571270156054200252440ustar00rootroot00000000000000require 'chef/version_constraint' <% if node_name %> node_name "<%= node_name %>" <% end %> file_cache_path "<%= file_cache_path %>" file_backup_path "<%= file_backup_path %>" cookbook_path <%= cookbooks_path.inspect %> <% if roles_path %> if Chef::VersionConstraint.new("< 11.8.0").include?(Chef::VERSION) role_path <%= roles_path.first.inspect %> else role_path <%= roles_path.inspect %> end <% end %> log_level <%= log_level.inspect %> verbose_logging <%= verbose_logging.inspect %> encrypted_data_bag_secret <%= encrypted_data_bag_secret.inspect %> <% if data_bags_path -%> data_bag_path <%= data_bags_path.inspect %> <% end %> <% if recipe_url -%> recipe_url "<%= recipe_url %>" <% end -%> <% if environments_path %> environment_path <%= environments_path.inspect %> <% end -%> <% if environment %> environment "<%= environment %>" <% end -%> http_proxy <%= http_proxy.inspect %> http_proxy_user <%= http_proxy_user.inspect %> http_proxy_pass <%= http_proxy_pass.inspect %> https_proxy <%= https_proxy.inspect %> https_proxy_user <%= https_proxy_user.inspect %> https_proxy_pass <%= https_proxy_pass.inspect %> no_proxy <%= no_proxy.inspect %> <% if formatter %> add_formatter "<%= formatter %>" <% end %> <% if custom_configuration -%> Chef::Config.from_file "<%= custom_configuration %>" <% end -%> vagrant-azure-2.0.0.pre1/vagrant-azure.gemspec000066400000000000000000000027251270156054200213100ustar00rootroot00000000000000# encoding: utf-8 # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License in the project root for license information. lib = File.expand_path('../lib', __FILE__) $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib) require 'vagrant-azure/version' Gem::Specification.new do |s| s.name = 'vagrant-azure' s.version = VagrantPlugins::Azure::VERSION s.authors = %w(Azure) s.description = 'Enable Vagrant to manage machines in Microsoft Azure.' s.summary = 'Enable Vagrant to manage Windows and Linux machines in Microsoft Azure.' s.homepage = 'https://github.com/azure/vagrant-azure' s.license = 'MIT' s.require_paths = ['lib'] s.files = `git ls-files`.split("\n") s.bindir = 'bin' s.executables = s.files.grep(%r{^bin/}) { |f| File.basename(f) } s.add_runtime_dependency 'azure_mgmt_resources', '~>0.2.1' s.add_runtime_dependency 'azure_mgmt_compute', '~>0.2.1' s.add_runtime_dependency 'azure_mgmt_network', '~>0.2.1' s.add_runtime_dependency 'azure_mgmt_storage', '~>0.2.1' s.add_runtime_dependency 'haikunator', '~>1.1' s.add_development_dependency 'bundler', '~>1.9' s.add_development_dependency 'rake', '~>11.1' s.add_development_dependency 'rspec', '~>3.4' s.add_development_dependency 'simplecov', '~>0.11.2' s.add_development_dependency 'coveralls', '~>0.8' end