vagrant-cloudstack 0.0.7 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f8e716acc56fff3d3c3f5ef8fb26979f7f7875df
-  data.tar.gz: 369722f08f4bad4184d7bc7a2a3a58915a0c6856
+  metadata.gz: 8e63f390567590eef3c9213dfac92b9d2d8d5f1b
+  data.tar.gz: 283ca0b998a55fdd780756abc76646152f2a6793
 SHA512:
-  metadata.gz: 79efc9d8aa0cdb6538fadc979ad66284ff041f738a2fa3ab27179af85d3f4a6902a3ebe4370d185a173d8fdf40a30e122b790aa45001244d3d9b425d5d767b22
-  data.tar.gz: b341f6e5def90c55abb4f5a84da18d2e079929cde583d0f1d48de8524c1c9f35740ee2ae3bd64a79535effda985820594a5fd653c3dd1ba983135e47e60d7334
+  metadata.gz: c848430cc6bffd286e66d8baa99403197ff3a1871130f541d88adcc834ac1c3660a6947d2db66ae266c2ddffae755fe6b2ccfbd83502dde5210cb52c83688659
+  data.tar.gz: c2a967dd880d8a3daa7209ec99afd8e44ffa0d2b8850d90deed017ea3d58890deb56bfa36a22631240362ea7d178741ed06eedac80dc7ae9eb16fcbe234d8f14

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+# 0.1.0
+* Plugin now enables parallelization by default.
+  * This behaviour can be turned off by invoking vagrant with
+    --no-parallel (this flag requires vagrant 1.2.1)
+* Added support for starting, stoping and reloading machines.
+* Added support for portforwarding and adding ssh keys.
+* Added support for basic network type.
+  * Basic means that there is no need to specify a network_id
+    to connecto to.
+  * Default network type is advanced.
+
 # 0.0.2 (May 3, 2013)
 
 * Renamed module from CloudStack to Cloudstack

data/README.md

@@ -2,6 +2,7 @@
 
 [![Build Status](https://travis-ci.org/klarna/vagrant-cloudstack.png?branch=master)](https://travis-ci.org/klarna/vagrant-cloudstack)
 [![Gem Version](https://badge.fury.io/rb/vagrant-cloudstack.png)](http://badge.fury.io/rb/vagrant-cloudstack)
+[![Dependency Status](https://gemnasium.com/klarna/vagrant-cloudstack.png)](https://gemnasium.com/klarna/vagrant-cloudstack)
 
 This is a fork of [mitchellh AWS Provider](https://github.com/mitchellh/vagrant-aws/).
 
@@ -64,6 +65,7 @@ Vagrant.configure("2") do |config|
     cloudstack.network_id = "AAAAAAAAAAAAAAAAAAA"
     cloudstack.zone_id = "AAAAAAAAAAAAAAAAAAA"
     cloudstack.project_id = "AAAAAAAAAAAAAAAAAAA"
+    cloudstack.network_type = "Advanced" # or "Basic"
   end
 end
 ```
@@ -101,10 +103,15 @@ This provider exposes quite a few provider-specific configuration options:
   to become "ready" in Cloudstack. Defaults to 120 seconds.
 * `domain_id` - Domain id to launch the instance into
 * `network_id` - Network uuid that the instance should use
+* `network_type` - CloudStack Network Type(default: Advanced)
 * `project_id` - Project uuid that the instance should belong to 
 * `service_offering_id`- Service offering uuid to use for the instance
 * `template_id` - Template uuid to use for the instance
 * `zone_id` - Zone uuid to launch the instance into
+* `keypair` - SSH keypair name
+* `pf_ip_address_id` - IP address ID for port forwarding rule
+* `pf_public_port` - Public port for port forwarding rule
+* `pf_private_port` - Private port for port forwarding rule
 
 These can be set like typical provider-specific configuration:
 

data/lib/vagrant-cloudstack/action/is_stopped.rb

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module Cloudstack
+    module Action
+      # This can be used with "Call" built-in to check if the machine
+      # is stopped and branch in the middleware.
+      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
+end

data/lib/vagrant-cloudstack/action/message_already_created.rb

@@ -7,7 +7,7 @@ module VagrantPlugins
         end
 
         def call(env)
-          env[:ui].info(I18n.t("vagrant_cloudstack.already_created"))
+          env[:ui].info(I18n.t("vagrant_cloudstack.already_status", :status => "created"))
           @app.call(env)
         end
       end

data/lib/vagrant-cloudstack/action/message_will_not_destroy.rb

@@ -0,0 +1,16 @@
+module VagrantPlugins
+  module Cloudstack
+    module Action
+      class MessageWillNotDestroy
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          env[:ui].info(I18n.t("vagrant_cloudstack.will_not_destroy", name: env[:machine].name))
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-cloudstack/action/read_ssh_info.rb

@@ -29,11 +29,34 @@ module VagrantPlugins
             return nil
           end
 
-          # Read the DNS info
-          return {
-            :host => server.nics[0]['ipaddress'],
-            :port => 22
-          }
+          # Get the Port forwarding config
+          domain = machine.provider_config.domain
+          domain_config = machine.provider_config.get_domain_config(domain)
+
+          pf_ip_address_id = domain_config.pf_ip_address_id
+          pf_public_port = domain_config.pf_public_port
+
+          if pf_ip_address_id and pf_public_port
+            begin
+              response = cloudstack.list_public_ip_addresses({:id => pf_ip_address_id})
+            rescue Fog::Compute::Cloudstack::Error => e
+              raise Errors::FogError, :message => e.message
+            end
+
+            if response["listpublicipaddressesresponse"]["count"] == 0
+              @logger.info("IP address #{pf_ip_address_id} not exists.")
+              env[:ui].info(I18n.t("IP address #{pf_ip_address_id} not exists."))
+              pf_ip_address = nil
+            else
+              pf_ip_address = response["listpublicipaddressesresponse"]["publicipaddress"][0]["ipaddress"]
+            end
+          end
+
+          unless pf_ip_address.nil?
+            return {:host => pf_ip_address, :port => pf_public_port}
+          else
+            return {:host => server.nics[0]['ipaddress'], :port => 22}
+          end
         end
       end
     end

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

@@ -22,7 +22,7 @@ module VagrantPlugins
 
           # Find the machine
           server = cloudstack.servers.get(machine.id)
-          if server.nil? || [:"shutting-down", :terminated].include?(server.state.to_sym)
+          if server.nil? || [:"shutting-down", :terminated].include?(server.state.downcase.to_sym)
             # The machine can't be found
             @logger.info("Machine not found or terminated, assuming it got destroyed.")
             machine.id = nil
@@ -30,7 +30,7 @@ module VagrantPlugins
           end
 
           # Return the state
-          return server.state.to_sym
+          return server.state.downcase.to_sym
         end
       end
     end

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

@@ -28,9 +28,20 @@ module VagrantPlugins
           domain_config       = env[:machine].provider_config.get_domain_config(domain)
           zone_id             = domain_config.zone_id
           network_id          = domain_config.network_id
+          network_type        = domain_config.network_type
           project_id          = domain_config.project_id
           service_offering_id = domain_config.service_offering_id
           template_id         = domain_config.template_id
+          keypair             = domain_config.keypair
+
+          pf_ip_address_id    = domain_config.pf_ip_address_id
+          pf_public_port      = domain_config.pf_public_port
+          pf_private_port     = domain_config.pf_private_port
+
+          # If there is no keypair then warn the user
+          if !keypair
+            env[:ui].warn(I18n.t("vagrant_cloudstack.launch_no_keypair"))
+          end
 
           # Launch!
           env[:ui].info(I18n.t("vagrant_cloudstack.launching_instance"))
@@ -39,6 +50,7 @@ module VagrantPlugins
           env[:ui].info(" -- Project UUID: #{project_id}") if project_id != nil
           env[:ui].info(" -- Zone UUID: #{zone_id}")
           env[:ui].info(" -- Network UUID: #{network_id}") if network_id
+          env[:ui].info(" -- Keypair: #{keypair}") if keypair
 
           local_user = ENV['USER'].dup
           local_user.gsub!(/[^-a-z0-9_]/i, "")
@@ -47,15 +59,26 @@ module VagrantPlugins
           display_name = local_user + "_" + prefix + "_#{Time.now.to_i}"
 
           begin
-            options = {
-              :display_name       => display_name,
-              :zone_id            => zone_id,
-              :flavor_id          => service_offering_id,
-              :image_id           => template_id,
-              :network_ids        => [network_id]
-            }
+            case network_type
+            when "Advanced"
+              options = {
+                :display_name       => display_name,
+                :zone_id            => zone_id,
+                :flavor_id          => service_offering_id,
+                :image_id           => template_id,
+                :network_ids        => [network_id]
+              }
+            when "Basic"
+              options = {
+                :display_name       => display_name,
+                :zone_id            => zone_id,
+                :flavor_id          => service_offering_id,
+                :image_id           => template_id
+              }
+            end
 
             options['project_id'] = project_id if project_id != nil
+            options['key_name'] = keypair if keypair != nil
 
             server = env[:cloudstack_compute].servers.create(options)
           rescue Fog::Compute::Cloudstack::NotFound => e
@@ -102,6 +125,11 @@ module VagrantPlugins
 
           @logger.info("Time to instance ready: #{env[:metrics]["instance_ready_time"]}")
 
+          if pf_ip_address_id and pf_public_port and pf_private_port
+            create_port_forwarding_rule(env, pf_ip_address_id,
+                                        pf_public_port, pf_private_port)
+          end
+
           if !env[:interrupted]
             env[:metrics]["instance_ssh_time"] = Util::Timer.time do
               # Wait for SSH to be ready.
@@ -135,6 +163,59 @@ module VagrantPlugins
           end
         end
 
+        def create_port_forwarding_rule(env, pf_ip_address_id, pf_public_port, pf_private_port)
+          env[:ui].info(I18n.t("vagrant_cloudstack.creating_port_forwarding_rule"))
+
+          begin
+            response = env[:cloudstack_compute].list_public_ip_addresses({:id => pf_ip_address_id})
+          rescue Fog::Compute::Cloudstack::Error => e
+            raise Errors::FogError, :message => e.message
+          end
+
+          if response["listpublicipaddressesresponse"]["count"] == 0
+            @logger.info("IP address #{pf_ip_address_id} not exists. Skip creating port forwarding rule.")
+            env[:ui].info(I18n.t("IP address #{pf_ip_address_id} not exists. Skip creating port forwarding rule."))
+            return
+          end
+
+          pf_ip_address = response["listpublicipaddressesresponse"]["publicipaddress"][0]["ipaddress"]
+
+          env[:ui].info(" -- IP address ID: #{pf_ip_address_id}")
+          env[:ui].info(" -- IP address: #{pf_ip_address}")
+          env[:ui].info(" -- Public port: #{pf_public_port}")
+          env[:ui].info(" -- Private port: #{pf_private_port}")
+
+          options = {
+            :ipaddressid      => pf_ip_address_id,
+            :publicport       => pf_public_port,
+            :privateport      => pf_private_port,
+            :protocol         => "tcp",
+            :virtualmachineid => env[:machine].id,
+            :openfirewall     => "true"
+          }
+
+          begin
+            job_id = env[:cloudstack_compute].create_port_forwarding_rule(options)["createportforwardingruleresponse"]["jobid"]
+            while true
+              response = env[:cloudstack_compute].query_async_job_result({:jobid => job_id})
+              if response["queryasyncjobresultresponse"]["jobstatus"] != 0
+                port_forwarding_rule =  response["queryasyncjobresultresponse"]["jobresult"]["portforwardingrule"]
+                break
+              else
+                sleep 2
+              end
+            end
+          rescue Fog::Compute::Cloudstack::Error => e
+            raise Errors::FogError, :message => e.message
+          end
+
+          # Save port forwarding rule id to the data dir so it can be released when the instance is destroyed
+          port_forwarding_file = env[:machine].data_dir.join('port_forwarding')
+          port_forwarding_file.open('w+') do |f|
+            f.write(port_forwarding_rule["id"])
+          end
+        end
+
         def terminate(env)
           destroy_env = env.dup
           destroy_env.delete(:interrupted)

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

@@ -0,0 +1,81 @@
+require "log4r"
+
+require 'vagrant/util/retryable'
+
+require 'vagrant-cloudstack/util/timer'
+
+module VagrantPlugins
+  module Cloudstack
+    module Action
+      # This starts a stopped instance.
+      class StartInstance
+        include Vagrant::Util::Retryable
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_cloudstack::action::start_instance")
+        end
+
+        def call(env)
+          # Initialize metrics if they haven't been
+          env[:metrics] ||= {}
+
+          server = env[:cloudstack_compute].servers.get(env[:machine].id)
+
+          env[:ui].info(I18n.t("vagrant_cloudstack.starting"))
+
+          begin
+            server.start
+
+            domain = env[:machine].provider_config.domain
+            domain_config = env[:machine].provider_config.get_domain_config(domain)
+
+            # Wait for the instance to be ready first
+            env[:metrics]["instance_ready_time"] = Util::Timer.time do
+              tries = domain_config.instance_ready_timeout / 2
+
+              env[:ui].info(I18n.t("vagrant_cloudstack.waiting_for_ready"))
+              begin
+                retryable(:on => Fog::Errors::TimeoutError, :tries => tries) do
+                  # If we're interrupted don't worry about waiting
+                  next if env[:interrupted]
+
+                  # Wait for the server to be ready
+                  server.wait_for(2) { ready? }
+                end
+              rescue Fog::Errors::TimeoutError
+                # Notify the user
+                raise Errors::InstanceReadyTimeout,
+                  timeout: domain_config.instance_ready_timeout
+              end
+            end
+          rescue Fog::Compute::Cloudstack::Error => e
+            raise Errors::FogError, :message => e.message
+          end
+
+          @logger.info("Time to instance ready: #{env[:metrics]["instance_ready_time"]}")
+
+          if !env[:interrupted]
+            env[:metrics]["instance_ssh_time"] = Util::Timer.time do
+              # Wait for SSH to be ready.
+              env[:ui].info(I18n.t("vagrant_cloudstack.waiting_for_ssh"))
+              while true
+                # If we're interrupted then just back out
+                break if env[:interrupted]
+                break if env[:machine].communicate.ready?
+                sleep 2
+              end
+            end
+
+            @logger.info("Time for SSH ready: #{env[:metrics]["instance_ssh_time"]}")
+
+            # Ready and booted!
+            env[:ui].info(I18n.t("vagrant_cloudstack.ready"))
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require "log4r"
+
+module VagrantPlugins
+  module Cloudstack
+    module Action
+      # This stops the running instance.
+      class StopInstance
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_cloudstack::action::stop_instance")
+        end
+
+        def call(env)
+          server = env[:cloudstack_compute].servers.get(env[:machine].id)
+
+          if env[:machine].state.id == :stopped
+            env[:ui].info(I18n.t("vagrant_cloudstack.already_status", :status => env[:machine].state.id))
+          else
+            env[:ui].info(I18n.t("vagrant_cloudstack.stopping"))
+            server.stop(!!env[:force_halt])
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

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

@@ -11,9 +11,29 @@ module VagrantPlugins
         end
 
         def call(env)
-          server = env[:cloudstack_compute].servers.get(env[:machine].id)
+          # Delete the Port forwarding rule
+          env[:ui].info(I18n.t("vagrant_cloudstack.deleting_port_forwarding_rule"))
+          port_forwarding_file = env[:machine].data_dir.join("port_forwarding")
+          if port_forwarding_file.file?
+            rule_id = port_forwarding_file.read
+            begin
+              job_id = env[:cloudstack_compute].delete_port_forwarding_rule({:id => rule_id})["deleteportforwardingruleresponse"]["jobid"]
+              while true
+                response = env[:cloudstack_compute].query_async_job_result({:jobid => job_id})
+                if response["queryasyncjobresultresponse"]["jobstatus"] != 0
+                  break
+                else
+                  sleep 2
+                end
+              end
+            rescue Fog::Compute::Cloudstack::Error => e
+              raise Errors::FogError, :message => e.message
+            end
+            port_forwarding_file.delete
+          end
 
           # Destroy the server and remove the tracking ID
+          server = env[:cloudstack_compute].servers.get(env[:machine].id)
           env[:ui].info(I18n.t("vagrant_cloudstack.terminating"))
           server.destroy
           env[:machine].id = nil

data/lib/vagrant-cloudstack/action/wait_for_state.rb

@@ -0,0 +1,41 @@
+require "log4r"
+require "timeout"
+
+module VagrantPlugins
+  module Cloudstack
+    module Action
+      # This action will wait for a machine to reach a specific state or quit by timeout
+      class WaitForState
+        # env[:result] will be false in case of timeout.
+        # @param [Symbol] state Target machine state.
+        # @param [Number] timeout Timeout in seconds.
+        def initialize(app, env, state, timeout)
+          @app     = app
+          @logger  = Log4r::Logger.new("vagrant_cloudstack::action::wait_for_state")
+          @state   = state
+          @timeout = timeout
+        end
+
+        def call(env)
+          env[:result] = true
+          if env[:machine].state.id == @state
+            @logger.info(I18n.t("vagrant_cloudstack.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

data/lib/vagrant-cloudstack/action.rb

@@ -8,12 +8,40 @@ module VagrantPlugins
       # 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|
+            if !env[:result]
+              b2.use MessageNotCreated
+              next
+            end
+
+            b2.use ConnectCloudstack
+            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 ConfigValidate
-          b.use ConnectCloudstack
-          b.use TerminateInstance
+          b.use Call, DestroyConfirm do |env, b2|
+            if env[:result]
+              b2.use ConfigValidate
+              b.use Call, IsCreated do |env2, b3|
+                if !env2[:result]
+                  b3.use MessageNotCreated
+                  next
+                end
+              end
+              b2.use ConnectCloudstack
+              b2.use TerminateInstance
+            else
+              b2.use MessageWillNotDestroy
+            end
+          end
         end
       end
 
@@ -84,21 +112,55 @@ module VagrantPlugins
         end
       end
 
+      def self.action_prepare_boot
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Provision
+          b.use SyncFolders
+          b.use WarnNetworks
+        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 ConfigValidate
+          b.use ConnectCloudstack
+          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 # TODO write a better message
+                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 ConnectCloudstack
           b.use Call, IsCreated do |env, b2|
-            if env[:result]
-              b2.use MessageAlreadyCreated
+            if !env[:result]
+              b2.use MessageNotCreated
               next
             end
 
-            b2.use TimedProvision
-            b2.use SyncFolders
-            b2.use WarnNetworks
-            b2.use RunInstance
+            b2.use action_halt
+            b2.use Call, WaitForState, :stopped, 120 do |env2, b3|
+              if env2[:result]
+                b3.use action_up
+              else
+                # TODO we couldn't reach :stopped, what now?
+              end
+            end
           end
         end
       end
@@ -107,13 +169,18 @@ module VagrantPlugins
       action_root = Pathname.new(File.expand_path("../action", __FILE__))
       autoload :ConnectCloudstack, action_root.join("connect_cloudstack")
       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 :RunInstance, action_root.join("run_instance")
+      autoload :StartInstance, action_root.join("start_instance")
+      autoload :StopInstance, action_root.join("stop_instance")
       autoload :SyncFolders, action_root.join("sync_folders")
       autoload :TimedProvision, action_root.join("timed_provision")
+      autoload :WaitForState, action_root.join("wait_for_state")
       autoload :WarnNetworks, action_root.join("warn_networks")
       autoload :TerminateInstance, action_root.join("terminate_instance")
     end

data/lib/vagrant-cloudstack/config.rb

@@ -48,6 +48,11 @@ module VagrantPlugins
       # @return [String]
       attr_accessor :network_id
 
+      # Network Type
+      #
+      # @return [String]
+      attr_accessor :network_type
+
       # Project uuid that the instance should belong to
       #
       # @return [String]
@@ -69,6 +74,26 @@ module VagrantPlugins
       # @return [String]
       attr_accessor :zone_id
 
+      # The name of the keypair to use.
+      #
+      # @return [String]
+      attr_accessor :keypair
+
+      # IP address id to use for port forwarding rule
+      #
+      # @return [String]
+      attr_accessor :pf_ip_address_id
+
+      # public port to use for port forwarding rule
+      #
+      # @return [String]
+      attr_accessor :pf_public_port
+
+      # private port to use for port forwarding rule
+      #
+      # @return [String]
+      attr_accessor :pf_private_port
+
       def initialize(domain_specific=false)
         @host                   = UNSET_VALUE
         @path                   = UNSET_VALUE
@@ -79,10 +104,15 @@ module VagrantPlugins
         @instance_ready_timeout = UNSET_VALUE
         @domain_id              = UNSET_VALUE
         @network_id             = UNSET_VALUE
+        @network_type           = UNSET_VALUE
         @project_id             = UNSET_VALUE
         @service_offering_id    = UNSET_VALUE
         @template_id            = UNSET_VALUE
         @zone_id                = UNSET_VALUE
+        @keypair                = UNSET_VALUE
+        @pf_ip_address_id       = UNSET_VALUE
+        @pf_public_port         = UNSET_VALUE
+        @pf_private_port        = UNSET_VALUE
 
         # Internal state (prefix with __ so they aren't automatically
         # merged)
@@ -180,6 +210,9 @@ module VagrantPlugins
         # Network uuid must be nil, since we can't default that
         @network_id = nil if @network_id == UNSET_VALUE
 
+        # NetworkType is 'Advanced' by default
+        @network_type = "Advanced" if @network_type == UNSET_VALUE
+
         # Project uuid must be nil, since we can't default that
         @project_id = nil if @project_id == UNSET_VALUE
 
@@ -192,6 +225,18 @@ module VagrantPlugins
         # Zone uuid must be nil, since we can't default that
         @zone_id = nil if @zone_id == UNSET_VALUE
 
+        # Keypair defaults to nil
+        @keypair = nil if @keypair == UNSET_VALUE
+
+        # IP address id must be nil, since we can't default that
+        @pf_ip_address_id = nil if @pf_ip_address_id == UNSET_VALUE
+
+        # Public port must be nil, since we can't default that
+        @pf_public_port = nil if @pf_public_port == UNSET_VALUE
+
+        # Private port must be nil, since we can't default that
+        @pf_private_port = nil if @pf_private_port == UNSET_VALUE
+
         # Compile our domain specific configurations only within
         # NON-DOMAIN-SPECIFIC configurations.
         if !@__domain_specific

data/lib/vagrant-cloudstack/plugin.rb

@@ -24,8 +24,7 @@ module VagrantPlugins
         Config
       end
 
-      provider(:cloudstack) do
-        # Setup logging and i18n
+      provider(:cloudstack, parallel: true) do        # Setup logging and i18n
         setup_logging
         setup_i18n
 

data/lib/vagrant-cloudstack/version.rb

@@ -1,5 +1,5 @@
 module VagrantPlugins
   module Cloudstack
-    VERSION = "0.0.7"
+    VERSION = "0.1.0"
   end
 end

data/locales/en.yml

@@ -1,7 +1,7 @@
 en:
   vagrant_cloudstack:
-    already_created: |-
-      The machine is already created.
+    already_status: |-
+      The machine is already %{status}.
     launching_instance: |-
       Launching an instance with the following settings...
     launch_no_keypair: |-
@@ -21,16 +21,27 @@ en:
       Make sure rsync is installed and the binary can be found in the PATH.
     rsync_folder: |-
       Rsyncing folder: %{hostpath} => %{guestpath}
+    starting: |-
+      Starting the instance...
+    stopping: |-
+      Stopping the instance...
     terminating: |-
       Terminating the instance...
     waiting_for_ready: |-
       Waiting for instance to become "ready"...
     waiting_for_ssh: |-
       Waiting for SSH to become available...
+    creating_port_forwarding_rule: |-
+      Creating a port forwarding rule for this instance ...
+    deleting_port_forwarding_rule: |-
+      Deleting the port forwarding rule ...
     warn_networks: |-
       Warning! The Cloudstack provider doesn't support any of the Vagrant
       high-level network configurations (`config.vm.network`). They
       will be silently ignored.
+    will_not_destroy: |-
+      The instance '%{name}' will not be destroyed, since the confirmation
+      was declined.
 
     config:
       api_key_required: |-
@@ -64,9 +75,19 @@ en:
         not created
       long_not_created: |-
         The instance is not created. Run `vagrant up` to create it.
+      short_stopped: |-
+        stopped
+      long_stopped: |-
+        The instance is stopped. Run `vagrant up` to start it.
 
-      short_Running: |-
+      short_stopping: |-
+        stopping
+      long_stopping: |-
+        The instance is stopping. Wait until is completely stopped to 
+        run `vagrant up` and start it.
+
+      short_running: |-
         running
-      long_Running: |-
+      long_running: |-
         The instance is running. To stop this machine, you can run
         `vagrant halt`. To destroy the machine, you can run `vagrant destroy`.

data/spec/vagrant-cloudstack/config_spec.rb

@@ -28,6 +28,10 @@ describe VagrantPlugins::Cloudstack::Config do
     its("service_offering_id")    { should be_nil }
     its("template_id")            { should be_nil }
     its("zone_id")                { should be_nil }
+    its("keypair")                { should be_nil }
+    its("pf_ip_address_id")       { should be_nil }
+    its("pf_public_port")         { should be_nil }
+    its("pf_private_port")        { should be_nil }
   end
 
   describe "overriding defaults" do
@@ -75,6 +79,10 @@ describe VagrantPlugins::Cloudstack::Config do
     let(:config_service_offering_id)    { "foo" }
     let(:config_template_id)            { "foo" }
     let(:config_zone_id)                { "foo" }
+    let(:config_keypair)                { "foo" }
+    let(:config_pf_ip_address_id)       { "foo" }
+    let(:config_pf_public_port)         { "foo" }
+    let(:config_pf_private_port)        { "foo" }
 
     def set_test_values(instance)
       instance.host                   = config_host
@@ -90,6 +98,10 @@ describe VagrantPlugins::Cloudstack::Config do
       instance.service_offering_id    = config_service_offering_id
       instance.template_id            = config_template_id
       instance.zone_id                = config_zone_id
+      instance.keypair                = config_keypair
+      instance.pf_ip_address_id       = config_pf_ip_address_id
+      instance.pf_public_port         = config_pf_public_port
+      instance.pf_private_port        = config_pf_private_port
     end
 
     it "should raise an exception if not finalized" do
@@ -122,6 +134,10 @@ describe VagrantPlugins::Cloudstack::Config do
       its("service_offering_id")    { should == config_service_offering_id }
       its("template_id")            { should == config_template_id }
       its("zone_id")                { should == config_zone_id }
+      its("keypair")                { should == config_keypair }
+      its("pf_ip_address_id")       { should == config_pf_ip_address_id }
+      its("pf_public_port")         { should == config_pf_public_port }
+      its("pf_private_port")        { should == config_pf_private_port }
     end
 
     context "with a specific config set" do
@@ -153,6 +169,10 @@ describe VagrantPlugins::Cloudstack::Config do
       its("service_offering_id")    { should == config_service_offering_id }
       its("template_id")            { should == config_template_id }
       its("zone_id")                { should == config_zone_id }
+      its("keypair")                { should == config_keypair }
+      its("pf_ip_address_id")       { should == config_pf_ip_address_id }
+      its("pf_public_port")         { should == config_pf_public_port }
+      its("pf_private_port")        { should == config_pf_private_port }
     end
 
     describe "inheritance of parent config" do

data/vagrant-cloudstack.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |s|
   s.version       = VagrantPlugins::Cloudstack::VERSION
   s.platform      = Gem::Platform::RUBY
   s.license       = "MIT"
-  s.authors       = ["Mitchell Hashimoto", "Carl Loa Odin", "Tor-Åke Fransson", "Roeland Kuipers", "atsaki"]
+  s.authors       = ["Mitchell Hashimoto", "Carl Loa Odin", "Tor-Åke Fransson", "Olle Lundberg", "Roeland Kuipers", "u-ichi", "atsaki"]
   s.email         = "carlodin@gmail.com"
   s.homepage      = "https://github.com/klarna/vagrant-cloudstack/"
   s.summary       = "Enables Vagrant to manage machines in Cloudstack."

metadata

@@ -1,18 +1,20 @@
 --- !ruby/object:Gem::Specification
 name: vagrant-cloudstack
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.1.0
 platform: ruby
 authors:
 - Mitchell Hashimoto
 - Carl Loa Odin
 - Tor-Åke Fransson
+- Olle Lundberg
 - Roeland Kuipers
+- u-ichi
 - atsaki
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-19 00:00:00.000000000 Z
+date: 2013-12-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fog
@@ -97,14 +99,19 @@ files:
 - Gemfile
 - lib/vagrant-cloudstack/action/connect_cloudstack.rb
 - lib/vagrant-cloudstack/action/is_created.rb
+- lib/vagrant-cloudstack/action/is_stopped.rb
 - lib/vagrant-cloudstack/action/message_already_created.rb
 - lib/vagrant-cloudstack/action/message_not_created.rb
+- lib/vagrant-cloudstack/action/message_will_not_destroy.rb
 - lib/vagrant-cloudstack/action/read_ssh_info.rb
 - lib/vagrant-cloudstack/action/read_state.rb
 - lib/vagrant-cloudstack/action/run_instance.rb
+- lib/vagrant-cloudstack/action/start_instance.rb
+- lib/vagrant-cloudstack/action/stop_instance.rb
 - lib/vagrant-cloudstack/action/sync_folders.rb
 - lib/vagrant-cloudstack/action/terminate_instance.rb
 - lib/vagrant-cloudstack/action/timed_provision.rb
+- lib/vagrant-cloudstack/action/wait_for_state.rb
 - lib/vagrant-cloudstack/action/warn_networks.rb
 - lib/vagrant-cloudstack/action.rb
 - lib/vagrant-cloudstack/config.rb