vagrant-cloudstack 0.10.0 → 1.0.0

data/lib/vagrant-cloudstack/action.rb

@@ -55,7 +55,7 @@ module VagrantPlugins
             end
 
             b2.use Provision
-            b2.use SyncFolders
+            b2.use SyncedFolders
           end
         end
       end
@@ -114,7 +114,7 @@ module VagrantPlugins
       def self.action_prepare_boot
         Vagrant::Action::Builder.new.tap do |b|
           b.use Provision
-          b.use SyncFolders
+          b.use SyncedFolders
           b.use WarnNetworks
         end
       end
@@ -177,7 +177,6 @@ module VagrantPlugins
       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")

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

@@ -34,9 +34,10 @@ module VagrantPlugins
           domain_config = machine.provider_config.get_domain_config(domain)
 
           pf_ip_address_id = domain_config.pf_ip_address_id
+          pf_ip_address    = domain_config.pf_ip_address
           pf_public_port   = domain_config.pf_public_port
 
-          if pf_ip_address_id and pf_public_port
+          if not pf_ip_address and 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
@@ -52,11 +53,18 @@ module VagrantPlugins
             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
+          ssh_info = {
+                       :host => pf_ip_address || server.nics[0]['ipaddress'],
+                       :port => pf_public_port
+                     }
+
+          ssh_info = ssh_info.merge({
+            :private_key_path => domain_config.ssh_key,
+            :password         => nil
+          }) unless domain_config.ssh_key.nil?
+          ssh_info = ssh_info.merge({ :username => domain_config.ssh_user }) unless domain_config.ssh_user.nil?
+
+          return ssh_info
         end
       end
     end

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

@@ -36,15 +36,22 @@ module VagrantPlugins
           template_id           = domain_config.template_id
           template_name         = domain_config.template_name
           keypair               = domain_config.keypair
+          static_nat            = domain_config.static_nat
           pf_ip_address_id      = domain_config.pf_ip_address_id
+          pf_ip_address         = domain_config.pf_ip_address
           pf_public_port        = domain_config.pf_public_port
           pf_private_port       = domain_config.pf_private_port
+          pf_open_firewall      = domain_config.pf_open_firewall
+          port_forwarding_rules = domain_config.port_forwarding_rules
+          firewall_rules        = domain_config.firewall_rules
           display_name          = domain_config.display_name
           group                 = domain_config.group
           security_group_ids    = domain_config.security_group_ids
           security_group_names  = domain_config.security_group_names
           security_groups       = domain_config.security_groups
           user_data             = domain_config.user_data
+          ssh_key               = domain_config.ssh_key
+          ssh_user              = domain_config.ssh_user
 
           # If for some reason the user have specified both network_name and network_id, take the id since that is
           # more specific than the name. But always try to fetch the name of the network to present to the user.
@@ -130,7 +137,7 @@ module VagrantPlugins
             }
 
             if network_type == "Advanced"
-              options['network_ids'] = [network_id]
+              options['network_ids'] = [network_id] if !network_id.nil?
             elsif network_type == "Basic"
               options['security_group_ids'] = security_group_ids
             end
@@ -189,9 +196,34 @@ 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)
+          if !static_nat.empty?
+            static_nat.each do |rule|
+              enable_static_nat(env, rule)
+            end
+          end
+
+          if (pf_ip_address_id or pf_ip_address) and pf_public_port and pf_private_port
+            port_forwarding_rule = {
+              :ipaddressid  => pf_ip_address_id,
+              :ipaddress    => pf_ip_address,
+              :protocol     => "tcp",
+              :publicport   => pf_public_port,
+              :privateport  => pf_private_port,
+              :openfirewall => pf_open_firewall
+            }
+            create_port_forwarding_rule(env, port_forwarding_rule)
+          end
+
+          if !port_forwarding_rules.empty?
+            port_forwarding_rules.each do |port_forwarding_rule|
+              create_port_forwarding_rule(env, port_forwarding_rule)
+            end
+          end
+
+          if !firewall_rules.empty?
+            firewall_rules.each do |firewall_rule|
+              create_firewall_rule(env, firewall_rule)
+            end
           end
 
           if !env[:interrupted]
@@ -264,39 +296,93 @@ 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"))
+        def enable_static_nat(env, rule)
+          env[:ui].info(I18n.t("vagrant_cloudstack.enabling_static_nat"))
+
+          ip_address_id = rule[:ipaddressid]
+          ip_address    = rule[:ipaddress]
+
+          if ip_address_id.nil? and ip_address.nil?
+            @logger.info("IP address is not specified. Skip enabling static nat.")
+            env[:ui].info(I18n.t("IP address is not specified. Skip enabling static nat."))
+            return
+          end
+
+          if ip_address_id.nil? and ip_address
+            ip_address_id = ip_to_id(env, ip_address)
+          elsif ip_address_id
+            ip_address = id_to_ip(env, ip_address_id)
+          end
+
+          env[:ui].info(" -- IP address : #{ip_address} (#{ip_address_id})")
+
+          options = {
+              :command          => "enableStaticNat",
+              :ipaddressid      => ip_address_id,
+              :virtualmachineid => env[:machine].id
+          }
 
           begin
-            response = env[:cloudstack_compute].list_public_ip_addresses({:id => pf_ip_address_id})
+            resp = env[:cloudstack_compute].request(options)
+            is_success = resp["enablestaticnatresponse"]["success"]
+
+            if is_success != "true"
+              env[:ui].warn(" -- Failed to enable static nat: #{resp["enablestaticnatresponse"]["errortext"]}")
+              return
+            end
           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."))
+          # Save ipaddress id to the data dir so it can be disabled when the instance is destroyed
+          static_nat_file = env[:machine].data_dir.join('static_nat')
+          static_nat_file.open('a+') do |f|
+            f.write("#{ip_address_id}\n")
+          end
+        end
+
+        def create_port_forwarding_rule(env, rule)
+          env[:ui].info(I18n.t("vagrant_cloudstack.creating_port_forwarding_rule"))
+
+          ip_address_id = rule[:ipaddressid]
+          ip_address    = rule[:ipaddress]
+
+          if ip_address_id.nil? and ip_address.nil?
+            @logger.info("IP address is not specified. Skip creating port forwarding rule.")
+            env[:ui].info(I18n.t("IP address is not specified. Skip creating port forwarding rule."))
             return
           end
 
-          pf_ip_address = response["listpublicipaddressesresponse"]["publicipaddress"][0]["ipaddress"]
+          if ip_address_id.nil? and ip_address
+            ip_address_id = ip_to_id(env, ip_address)
+          elsif ip_address_id
+            ip_address = id_to_ip(env, ip_address_id)
+          end
 
-          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}")
+          env[:ui].info(" -- IP address    : #{ip_address} (#{ip_address_id})")
+          env[:ui].info(" -- Protocol      : #{rule[:protocol]}")
+          env[:ui].info(" -- Public port   : #{rule[:publicport]}")
+          env[:ui].info(" -- Private port  : #{rule[:privateport]}")
+          env[:ui].info(" -- Open Firewall : #{rule[:openfirewall]}")
 
           options = {
-              :ipaddressid      => pf_ip_address_id,
-              :publicport       => pf_public_port,
-              :privateport      => pf_private_port,
-              :protocol         => "tcp",
-              :virtualmachineid => env[:machine].id,
-              :openfirewall     => "true"
+              :ipaddressid      => ip_address_id,
+              :publicport       => rule[:publicport],
+              :privateport      => rule[:privateport],
+              :protocol         => rule[:protocol],
+              :openfirewall     => rule[:openfirewall],
+              :virtualmachineid => env[:machine].id
           }
 
           begin
-            job_id = env[:cloudstack_compute].create_port_forwarding_rule(options)["createportforwardingruleresponse"]["jobid"]
+            resp = env[:cloudstack_compute].create_port_forwarding_rule(options)
+            job_id = resp["createportforwardingruleresponse"]["jobid"]
+
+            if job_id.nil?
+              env[:ui].warn(" -- Failed to create port forwarding rule: #{resp["createportforwardingruleresponse"]["errortext"]}")
+              return
+            end
+
             while true
               response = env[:cloudstack_compute].query_async_job_result({:jobid => job_id})
               if response["queryasyncjobresultresponse"]["jobstatus"] != 0
@@ -312,8 +398,74 @@ module VagrantPlugins
 
           # 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"])
+          port_forwarding_file.open('a+') do |f|
+            f.write("#{port_forwarding_rule["id"]}\n")
+          end
+        end
+
+        def create_firewall_rule(env, rule)
+          env[:ui].info(I18n.t("vagrant_cloudstack.creating_firewall_rule"))
+
+          ip_address_id = rule[:ipaddressid]
+          ip_address    = rule[:ipaddress]
+
+          if ip_address_id.nil? and ip_address.nil?
+            @logger.info("IP address is not specified. Skip creating firewall rule.")
+            env[:ui].info(I18n.t("IP address is not specified. Skip creating firewall rule."))
+            return
+          end
+
+          if ip_address_id.nil? and ip_address
+            ip_address_id = ip_to_id(env, ip_address)
+          elsif ip_address_id
+            ip_address = id_to_ip(env, ip_address_id)
+          end
+
+          env[:ui].info(" -- IP address : #{ip_address} (#{ip_address_id})")
+          env[:ui].info(" -- Protocol   : #{rule[:protocol]}")
+          env[:ui].info(" -- CIDR list  : #{rule[:cidrlist]}")
+          env[:ui].info(" -- Start port : #{rule[:startport]}")
+          env[:ui].info(" -- End port   : #{rule[:endport]}")
+          env[:ui].info(" -- ICMP code  : #{rule[:icmpcode]}")
+          env[:ui].info(" -- ICMP type  : #{rule[:icmptype]}")
+
+          options = {
+              :command          => "createFirewallRule",
+              :ipaddressid      => ip_address_id,
+              :protocol         => rule[:protocol],
+              :cidrlist         => rule[:cidrlist],
+              :startport        => rule[:startport],
+              :endeport         => rule[:endport],
+              :icmpcode         => rule[:icmpcode],
+              :icmptype         => rule[:icmptype]
+          }
+
+          begin
+            resp = env[:cloudstack_compute].request(options)
+            job_id = resp["createfirewallruleresponse"]["jobid"]
+
+            if job_id.nil?
+              env[:ui].warn(" -- Failed to create firewall rule: #{resp["createfirewallruleresponse"]["errortext"]}")
+              return
+            end
+
+            while true
+              response = env[:cloudstack_compute].query_async_job_result({:jobid => job_id})
+              if response["queryasyncjobresultresponse"]["jobstatus"] != 0
+                firewall_rule = response["queryasyncjobresultresponse"]["jobresult"]["firewallrule"]
+                break
+              else
+                sleep 2
+              end
+            end
+          rescue Fog::Compute::Cloudstack::Error => e
+            raise Errors::FogError, :message => e.message
+          end
+
+          # Save firewall rule id to the data dir so it can be released when the instance is destroyed
+          firewall_file = env[:machine].data_dir.join('firewall')
+          firewall_file.open('a+') do |f|
+            f.write("#{firewall_rule["id"]}\n")
           end
         end
 
@@ -328,23 +480,44 @@ module VagrantPlugins
         private
 
         def translate_from_to(env, resource_type, options)
-          pluralised_type = "#{resource_type}s"
-          full_response   = env[:cloudstack_compute].send("list_#{pluralised_type}".to_sym, options)
+          if resource_type == "public_ip_address"
+            pluralised_type = "public_ip_addresses"
+          else
+            pluralised_type = "#{resource_type}s"
+          end
+
+          full_response = env[:cloudstack_compute].send("list_#{pluralised_type}".to_sym, options)
           full_response["list#{pluralised_type.tr('_', '')}response"][resource_type.tr('_', '')]
         end
 
-        def name_to_id(env, resource_name, resource_type, options={})
-          env[:ui].info("Fetching UUID for #{resource_type} named '#{resource_name}'")
+        def resourcefield_to_id(env, resource_type, resource_field, resource_field_value, options={})
+          env[:ui].info("Fetching UUID for #{resource_type} with #{resource_field} '#{resource_field_value}'")
           full_response = translate_from_to(env, resource_type, options)
-          result        = full_response.find { |type| type["name"] == resource_name }
+          result        = full_response.find {|type| type[resource_field] == resource_field_value }
           result['id']
         end
 
-        def id_to_name(env, resource_id, resource_type, options={})
-          env[:ui].info("Fetching name for #{resource_type} with UUID '#{resource_id}'")
+        def id_to_resourcefield(env, resource_id, resource_type, resource_field, options={})
+          env[:ui].info("Fetching #{resource_field} for #{resource_type} with UUID '#{resource_id}'")
           options = options.merge({'id' => resource_id})
           full_response = translate_from_to(env, resource_type, options)
-          full_response[0]['name']
+          full_response[0][resource_field]
+        end
+
+        def name_to_id(env, resource_name, resource_type, options={})
+          resourcefield_to_id(env, resource_type, 'name', resource_name, options)
+        end
+
+        def id_to_name(env, resource_id, resource_type, options={})
+          id_to_resourcefield(env, resource_id, resource_type, 'name', options)
+        end
+
+        def ip_to_id(env, ip_address, options={})
+          resourcefield_to_id(env, 'public_ip_address', 'ipaddress', ip_address, options)
+        end
+
+        def id_to_ip(env, ip_address_id, options={})
+          id_to_resourcefield(env, ip_address_id, 'public_ip_address', 'ipaddress', options)
         end
       end
     end

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

@@ -11,29 +11,90 @@ module VagrantPlugins
         end
 
         def call(env)
+          # Disable Static NAT
+          env[:ui].info(I18n.t("vagrant_cloudstack.disabling_static_nat"))
+          static_nat_file = env[:machine].data_dir.join("static_nat")
+          if static_nat_file.file?
+            File.open(static_nat_file, "r").each_line do |line|
+              ip_address_id = line.strip
+              begin
+                options = {
+                  :command => "disableStaticNat",
+                  :ipaddressid => ip_address_id
+                }
+                resp = env[:cloudstack_compute].request(options)
+                job_id = resp["disablestaticnatresponse"]["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
+            end
+            static_nat_file.delete
+          end
+
           # 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
+            File.open(port_forwarding_file, "r").each_line do |line|
+              rule_id = line.strip
+              begin
+                resp = env[:cloudstack_compute].delete_port_forwarding_rule({:id => rule_id})
+                job_id = resp["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
-            rescue Fog::Compute::Cloudstack::Error => e
-              raise Errors::FogError, :message => e.message
             end
             port_forwarding_file.delete
           end
 
+          # Delete the Firewall rule
+          env[:ui].info(I18n.t("vagrant_cloudstack.deleting_firewall_rule"))
+          firewall_file = env[:machine].data_dir.join("firewall")
+          if firewall_file.file?
+            File.open(firewall_file, "r").each_line do |line|
+              rule_id = line.strip
+              begin
+                options = {
+                  :command => "deleteFirewallRule",
+                  :id      => rule_id
+                }
+                resp = env[:cloudstack_compute].request(options)
+                job_id = resp["deletefirewallruleresponse"]["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
+            end
+            firewall_file.delete
+          end
+
           # Destroy the server and remove the tracking ID
-          server = env[:cloudstack_compute].servers.get(env[:machine].id)
+          unless env[:machine].id.nil?
+              server = env[:cloudstack_compute].servers.get(env[:machine].id)
+
           env[:ui].info(I18n.t("vagrant_cloudstack.terminating"))
 
           job = server.destroy
@@ -47,6 +108,11 @@ module VagrantPlugins
             end
           end
 
+            else
+                env[:ui].info(I18n.t("vagrant_cloudstack.no_instance_found"))
+                return
+          end
+
           security_groups_file = env[:machine].data_dir.join("security_groups")
           if security_groups_file.file?
             File.open(security_groups_file, "r").each_line do |line|