vagrant-azure 2.0.0.pre7 → 2.0.0.pre8

data/docs/basic_windows/readme.md

@@ -0,0 +1,12 @@
+# Basic Windows SQL Server 2016 Machine
+This scenario will build a Windows SQL Server 2016 machine.
+
+Before you attempt this scenario, ensure you have followed the [getting started docs](../../readme.md#getting-started).
+
+## Vagrant up
+- In this directory, run the following
+  ```bash
+  vagrant up --provider=azure
+  ```
+  
+To clean up, run `vagrant destroy`

data/docs/custom_vhd/Vagrantfile

@@ -0,0 +1,16 @@
+
+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|
+    azure.location = "westus"
+
+    # change this URI to your storage account blob within the same region as specified above
+    azure.vm_vhd_uri = "https://vagrantimages.blob.core.windows.net/vhds/xenial-server-cloudimg-amd64-disk1.vhd"
+    azure.vm_operating_system = "Linux"
+  end
+
+  config.vm.provision "shell", inline: "echo Hello, World"
+end

data/docs/custom_vhd/readme.md

@@ -0,0 +1,48 @@
+# Ubuntu Xenial Machine from VHD
+This scenario will build a custom image from a prepared Ubuntu Xenial VHD. This will build an Azure Managed
+Image from the custom generalized VHD. The Azure Managed Image will be used to create a new Azure Virtual
+Machine.
+
+To see more information about this scenario, see [Prepare an Ubuntu virtual machine for Azure](https://docs.microsoft.com/en-us/azure/virtual-machines/linux/create-upload-ubuntu)
+
+Before you attempt this scenario, ensure you have followed the [getting started docs](../../readme.md#getting-started).
+
+If you wanted to build a more customized image, you could do the same with your own VHD manually by following these 
+[instructions](https://docs.microsoft.com/en-us/azure/virtual-machines/linux/create-upload-ubuntu?toc=%2fazure%2fvirtual-machines%2flinux%2ftoc.json#manual-steps).
+
+## Vagrant up
+We will set this up with Azure CLI and then run Vagrant after we've provisioned the needed Azure resources.
+- Login to Azure CLI (if not already logged in)
+  ```bash
+  az login
+  ```
+- Create a resource group for your VHDs (assuming westus)
+  ```bash
+  az group create -n vagrantimages -l westus
+  ```
+- Create a storage account in the region you'd like to deploy
+  ```bash
+  # insert your own name for the storage account DNS name (-n)
+  az storage account create -g vagrantimages -n vagrantimagesXXXX --sku Standard_LRS -l westus
+  ```
+- Download and unzip the VHD from Ubuntu
+  ```bash
+  wget -qO- -O tmp.zip http://cloud-images.ubuntu.com/releases/xenial/release/ubuntu-16.04-server-cloudimg-amd64-disk1.vhd.zip && unzip tmp.zip && rm tmp.zip
+  ```
+- Upload the VHD to your storage account in the vhds container
+  ```bash
+  conn_string=$(az storage account show-connection-string -g vagrantimages -n vagrantimagesXXXX -o tsv)
+  az storage container create -n vhds --connection-string $conn_string
+  az storage container create -n vhds vagrantimagesXXXX
+  az storage blob upload -c vhds -n xenial-server-cloudimg-amd64-disk1.vhd -f xenial-server-cloudimg-amd64-disk1.vhd --connection-string $conn_string
+  ```
+- Update Vagrantfile with the URI of your uploaded blob (`azure.vm_vhd_uri`).
+- Vagrant up
+  ```bash
+  vagrant up --provider=azure
+  ```
+  
+To clean up, run `vagrant destroy`
+  
+ 
+ 

data/docs/data_disks/Vagrantfile

@@ -0,0 +1,16 @@
+
+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|
+    azure.location = "westus"
+
+    azure.data_disks = [
+        { name: "foo", size_gb: 30 }
+    ]
+  end
+
+  config.vm.provision "shell", inline: "echo Hello, World"
+end

data/docs/data_disks/readme.md

@@ -0,0 +1,20 @@
+# Linux Machine with Empty Data Disks
+This scenario will build an Ubuntu 16.04 machine with data disks attached to the virtual machine.
+
+To see more information about this scenario, see [How to Attach a Data Disk to a Linux VM](https://docs.microsoft.com/en-us/azure/virtual-machines/linux/classic/attach-disk)
+
+Before you attempt this scenario, ensure you have followed the [getting started docs](../../readme.md#getting-started).
+
+*Note: data disk support is preview and will likely change before becoming stable*
+
+## Vagrant up
+- In this directory, run the following
+  ```bash
+  vagrant up --provider=azure
+  ```
+- The Vagrant file specifies on data disk named foo. The foo disk is not formatted, nor mounted. If you
+  would like to use the disk, you will need to format and mount the drive. For instructions on how to do that,
+  see: https://docs.microsoft.com/en-us/azure/virtual-machines/linux/classic/attach-disk#initialize-a-new-data-disk-in-linux.
+  In the next rev of data disks, we'll handle mounting and formatting.
+  
+To clean up, run `vagrant destroy`

data/docs/managed_image/Vagrantfile

@@ -0,0 +1,15 @@
+
+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|
+    azure.location = "westus"
+
+    # replace this with your managed image resource id
+    azure.vm_managed_image_id = "/subscriptions/{subscription_id}/resourceGroups/{group}/providers/Microsoft.Compute/images/{image_name}"
+  end
+
+  config.vm.provision "shell", inline: "echo Hello, World"
+end

data/docs/managed_image/readme.md

@@ -0,0 +1,66 @@
+# Ubuntu Machine from a Captured Managed Image
+This scenario will build a machine from a captured managed image. We will build a VM with Azure CLI, capture 
+an image of the VM and use that image reference for a new Vagrant machine.
+
+To see more information about this scenario, see [Create a VM from the captured image](https://docs.microsoft.com/en-us/azure/virtual-machines/linux/capture-image#step-3-create-a-vm-from-the-captured-image)
+
+Before you attempt this scenario, ensure you have followed the [getting started docs](../../readme.md#getting-started).
+
+## Vagrant up
+We will set this up with Azure CLI and then run Vagrant after we've provisioned the needed Azure resources.
+- Login to Azure CLI (if not already logged in)
+  ```bash
+  az login
+  ```
+- Create a resource group for your VHDs (assuming westus)
+  ```bash
+  az group create -n vagrant -l westus
+  ```
+- Create a new VM
+  ```bash
+  az vm create -g vagrant -n vagrant-box --admin-username deploy --image UbuntuLTS
+  ```
+- Capture an image of the VM
+  ```bash
+  az vm deallocate -g vagrant -n vagrant-box
+  az vm generalize -g vagrant -n vagrant-box
+  az image create -g vagrant --name vagrant-box-image --source vagrant-box
+  ```
+  You should see json output from the `az image create` command. Extract the "id" value from below for use in your Vagrantfile.
+  ```json
+    {
+      "id": "/subscriptions/XXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXX/resourceGroups/vagrant/providers/Microsoft.Compute/images/vagrant-box-image",
+      "location": "westus",
+      "name": "vagrant-box-image",
+      "provisioningState": "Succeeded",
+      "resourceGroup": "vagrant",
+      "sourceVirtualMachine": {
+        "id": "/subscriptions/XXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXX/resourceGroups/vagrant-test/providers/Microsoft.Compute/virtualMachines/vagrant-box",
+        "resourceGroup": "vagrant"
+      },
+      "storageProfile": {
+        "dataDisks": [],
+        "osDisk": {
+          "blobUri": null,
+          "caching": "ReadWrite",
+          "diskSizeGb": null,
+          "managedDisk": {
+            "id": "/subscriptions/XXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXX/resourceGroups/vagrant-test/providers/Microsoft.Compute/disks/osdisk_5ZglGr7Rj4",
+            "resourceGroup": "vagrant"
+          },
+          "osState": "Generalized",
+          "osType": "Linux",
+          "snapshot": null
+        }
+      },
+      "tags": null,
+      "type": "Microsoft.Compute/images"
+    }
+  ```
+- Update the Vagrantfile in this directory with the URI of your managed image resource (`azure.vm_managed_image_id`).
+- Vagrant up
+  ```bash
+  vagrant up --provider=azure
+  ```
+  
+To clean up, run `vagrant destroy`

data/docs/readme.md

@@ -0,0 +1,30 @@
+# Vagrant Azure Scenario Docs
+Here you can find some common scenarios for using Azure plugin for Vagrant.
+
+## Prerequisites
+Before you attempt any scenario, ensure you have followed the [getting started docs](../readme.md#getting-started).
+
+## Scenarios
+
+### [Basic Linux Setup](./basic_linux)
+Setup a simple Ubuntu 16.04 machine
+
+### [Basic Windows Setup](./basic_windows)
+Setup a Windows SQL Server 2016 machine
+
+### [Ubuntu Xenial Machine from VHD](./custom_vhd)
+Setup an Ubuntu box from a custom VHD
+
+### [Managed Image Reference](./managed_image)
+Setup a VM from a managed image reference captured from a previously created Azure VM.
+
+### [Data Disks (empty disk)](./data_disks)
+Setup an Ubuntu box with an empty attached disk
+
+## Azure Boxes
+
+The vagrant-azure plugin provides the ability to use ```Azure``` boxes with Vagrant. Please see the example box 
+provided in [example_box](https://github.com/azure/vagrant-azure/tree/v2.0/example_box) directory and follow the 
+instructions there to build an `azure` box.
+
+For general Vagrant documentation see [Vagrant Docs](http://docs.vagrantup.com/v2/).

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

@@ -1,13 +1,14 @@
 # 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'
+require "log4r"
+require "json"
+require "azure_mgmt_resources"
+require "vagrant-azure/util/machine_id_helper"
+require "vagrant-azure/util/template_renderer"
+require "vagrant-azure/util/managed_image_helper"
+require "vagrant-azure/util/timer"
+require "haikunator"
 
 module VagrantPlugins
   module Azure
@@ -15,10 +16,11 @@ module VagrantPlugins
       class RunInstance
         include Vagrant::Util::Retryable
         include VagrantPlugins::Azure::Util::MachineIdHelper
+        include VagrantPlugins::Azure::Util::ManagedImagedHelper
 
         def initialize(app, env)
           @app = app
-          @logger = Log4r::Logger.new('vagrant_azure::action::run_instance')
+          @logger = Log4r::Logger.new("vagrant_azure::action::run_instance")
         end
 
         def call(env)
@@ -29,14 +31,20 @@ module VagrantPlugins
 
           # Get the configs
           config                         = machine.provider_config
+
+          config.dns_name ||= config.vm_name
+          config.nsg_name ||= config.vm_name
+
           endpoint                       = config.endpoint
           resource_group_name            = config.resource_group_name
           location                       = config.location
           ssh_user_name                  = machine.config.ssh.username
           vm_name                        = config.vm_name
-          vm_password                    = config.vm_password
           vm_size                        = config.vm_size
           vm_image_urn                   = config.vm_image_urn
+          vm_vhd_uri                     = config.vm_vhd_uri
+          vm_operating_system            = config.vm_operating_system
+          vm_managed_image_id            = config.vm_managed_image_id
           virtual_network_name           = config.virtual_network_name
           subnet_name                    = config.subnet_name
           tcp_endpoints                  = config.tcp_endpoints
@@ -45,8 +53,8 @@ module VagrantPlugins
           admin_password                 = config.admin_password
           winrm_port                     = machine.config.winrm.port
           winrm_install_self_signed_cert = config.winrm_install_self_signed_cert
-          dns_label_prefix               = Haikunator.haikunate(100)
-          deployment_template            = config.deployment_template
+          dns_label_prefix               = config.dns_name
+          nsg_label_prefix               = config.nsg_name
 
           # Launch!
           env[:ui].info(I18n.t('vagrant_azure.launching_instance'))
@@ -58,64 +66,79 @@ module VagrantPlugins
           env[:ui].info(" -- Admin Username: #{admin_user_name}") if admin_user_name
           env[:ui].info(" -- VM Name: #{vm_name}")
           env[:ui].info(" -- VM Size: #{vm_size}")
-          env[:ui].info(" -- Image URN: #{vm_image_urn}")
+
+          if !vm_vhd_uri.nil?
+            env[:ui].info(" -- Custom VHD URI: #{vm_vhd_uri}")
+            env[:ui].info(" -- Custom OS: #{vm_operating_system}")
+          elsif !vm_managed_image_id.nil?
+            env[:ui].info(" -- Managed Image Id: #{vm_managed_image_id}")
+          else
+            env[:ui].info(" -- Image URN: #{vm_image_urn}")
+          end
+
           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
           env[:ui].info(" -- DNS Label Prefix: #{dns_label_prefix}")
 
-          image_publisher, image_offer, image_sku, image_version = vm_image_urn.split(':')
+          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']}")
+          @logger.info("Time to fetch os image details: #{env[:metrics]["get_image_details"]}")
 
           deployment_params = {
             dnsLabelPrefix:       dns_label_prefix,
+            nsgLabelPrefix:       nsg_label_prefix,
             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,
           }
 
           # we need to pass different parameters depending upon the OS
-          operating_system = get_image_os(image_details)
+          # if custom image, then require vm_operating_system
+          operating_system = if vm_vhd_uri
+                               vm_operating_system
+                             elsif vm_managed_image_id
+                               get_managed_image_os(azure, vm_managed_image_id)
+                             else
+                               get_image_os(azure, location, image_publisher, image_offer, image_sku, image_version)
+                             end
 
           template_params = {
             availability_set_name:          availability_set_name,
-            operating_system:               operating_system,
             winrm_install_self_signed_cert: winrm_install_self_signed_cert,
             winrm_port:                     winrm_port,
             dns_label_prefix:               dns_label_prefix,
+            nsg_label_prefix:               nsg_label_prefix,
             location:                       location,
-            deployment_template:            deployment_template
+            image_publisher:                image_publisher,
+            image_offer:                    image_offer,
+            image_sku:                      image_sku,
+            image_version:                  image_version,
+            vhd_uri:                        vm_vhd_uri,
+            operating_system:               operating_system,
+            data_disks:                     config.data_disks
           }
 
-          if operating_system != 'Windows'
+          if operating_system != "Windows"
             private_key_paths = machine.config.ssh.private_key_path
             if private_key_paths.nil? || 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) }
+            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!(adminUsername:  ssh_user_name)
             deployment_params.merge!(sshKeyData: File.read(paths_to_pub.first))
-            communicator_message = 'vagrant_azure.waiting_for_ssh'
+            communicator_message = "vagrant_azure.waiting_for_ssh"
           else
             env[:machine].config.vm.communicator = :winrm
             machine.config.winrm.port = winrm_port
             machine.config.winrm.username = admin_user_name
             machine.config.winrm.password = admin_password
-            communicator_message = 'vagrant_azure.waiting_for_winrm'
+            communicator_message = "vagrant_azure.waiting_for_winrm"
             windows_params = {
               adminUsername:  admin_user_name,
               adminPassword:  admin_password,
@@ -124,44 +147,28 @@ module VagrantPlugins
             deployment_params.merge!(windows_params)
           end
 
-          unless tcp_endpoints.nil?
-
-            if tcp_endpoints.is_a?(Array)
-              # https://docs.microsoft.com/en-us/azure/virtual-network/virtual-networks-nsg#Nsg-rules
-              if tcp_endpoints.length + 133 > 4096
-                raise I18n.t('vagrant_azure.too_many_tcp_endpoints', count: tcp_endpoints.length)
-              end 
-              endpoints = tcp_endpoints
-            elsif tcp_endpoints.is_a?(String) || (tcp_endpoints.is_a?(Integer) && tcp_endpoints > 0)
-              endpoints = [tcp_endpoints]
-            else
-              raise I18n.t('vagrant_azure.unknown_type_as_tcp_endpoints', input: tcp_endpoints)
-            end
-          else 
-            endpoints = []
-          end
-          template_params.merge!(endpoints: endpoints)
+          template_params.merge!(endpoints: get_endpoints(tcp_endpoints))
 
           env[:ui].info(" -- Create or Update of Resource Group: #{resource_group_name}")
-          env[:metrics]['put_resource_group'] = Util::Timer.time do
+          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?})
+          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
+          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')
+          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
+            env[:metrics]["instance_ssh_time"] = Util::Timer.time do
               # Wait for SSH/WinRM to be ready.
               env[:ui].info(I18n.t(communicator_message))
               network_ready_retries = 0
@@ -194,14 +201,42 @@ module VagrantPlugins
           @app.call(env)
         end
 
-        def get_image_os(image_details)
+        def get_endpoints(tcp_endpoints)
+          endpoints = [8443]
+          unless tcp_endpoints.nil?
+            if tcp_endpoints.is_a?(Array)
+              # https://docs.microsoft.com/en-us/azure/virtual-network/virtual-networks-nsg#Nsg-rules
+              if tcp_endpoints.length + 133 > 4096
+                raise I18n.t("vagrant_azure.too_many_tcp_endpoints", count: tcp_endpoints.length)
+              end
+              endpoints = tcp_endpoints
+            elsif tcp_endpoints.is_a?(String) || (tcp_endpoints.is_a?(Integer) && tcp_endpoints > 0)
+              endpoints = [tcp_endpoints]
+            else
+              raise I18n.t("vagrant_azure.unknown_type_as_tcp_endpoints", input: tcp_endpoints)
+            end
+          end
+          endpoints
+        end
+
+        def get_image_os(azure, location, publisher, offer, sku, version)
+          image_details = get_image_details(azure, location, publisher, offer, sku, version)
           image_details.os_disk_image.operating_system
         end
 
+        def get_managed_image_os(azure, image_id)
+          _, group, name = image_id_captures(image_id)
+          image_details = azure.compute.images.get(group, name)
+          image_details.storage_profile.os_disk.os_type
+        end
+
         def get_image_details(azure, location, publisher, offer, sku, version)
-          if version == 'latest'
+          if version == "latest"
             images = azure.compute.virtual_machine_images.list(location, publisher, offer, sku)
             latest = images.sort_by(&:name).last
+            if latest.nil?
+              raise "Unrecognized location, publisher, offer, sku, version combination: #{location}, #{publisher}, #{offer}, #{sku}, latest. Run `az vm image list` to ensure the image is available."
+            end
             azure.compute.virtual_machine_images.get(location, publisher, offer, sku, latest.name)
           else
             azure.compute.virtual_machine_images.get(location, publisher, offer, sku, version)
@@ -224,37 +259,28 @@ module VagrantPlugins
         # This method generates the deployment template
         def render_deployment_template(options)
           self_signed_cert_resource = nil
-          if options[:operating_system] == 'Windows' && options[:winrm_install_self_signed_cert]
-            setup_winrm_powershell = Vagrant::Util::TemplateRenderer.render('arm/setup-winrm.ps1', options.merge({template_root: template_root}))
+          if options[:operating_system] == "Windows" && options[:winrm_install_self_signed_cert]
+            setup_winrm_powershell = VagrantPlugins::Azure::Util::TemplateRenderer.render("arm/setup-winrm.ps1", options)
             encoded_setup_winrm_powershell = setup_winrm_powershell.
               gsub("'", "', variables('singleQuote'), '").
               gsub("\r\n", "\n").
               gsub("\n", "; ")
-            self_signed_cert_resource = Vagrant::Util::TemplateRenderer.render('arm/selfsignedcert.json', options.merge({template_root: template_root, setup_winrm_powershell: encoded_setup_winrm_powershell}))
+            self_signed_cert_resource = VagrantPlugins::Azure::Util::TemplateRenderer.render("arm/selfsignedcert.json", options.merge({setup_winrm_powershell: encoded_setup_winrm_powershell}))
           end
-          Vagrant::Util::TemplateRenderer.render('arm/deployment.json', options.merge({ template_root: template_root, self_signed_cert_resource: self_signed_cert_resource}))
+          VagrantPlugins::Azure::Util::TemplateRenderer.render("arm/deployment.json", options.merge({self_signed_cert_resource: self_signed_cert_resource}))
         end
 
         def build_deployment_params(template_params, deployment_params)
           params = ::Azure::ARM::Resources::Models::Deployment.new
           params.properties = ::Azure::ARM::Resources::Models::DeploymentProperties.new
-          if template_params[:deployment_template].nil?
-            params.properties.template = JSON.parse(render_deployment_template(template_params))
-          else
-            params.properties.template = JSON.parse(template_params[:deployment_template])
-          end
+          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')
+          Hash[*options.map { |k, v| [k, { value: v } ] }.flatten]
         end
 
         def terminate(env)