vagrant-vcloud 0.1.2 → 0.2.0

data/lib/vagrant-vcloud/action/resume.rb

@@ -1,29 +1,21 @@
-require "i18n"
-
 module VagrantPlugins
   module VCloud
     module Action
       class Resume
-
         def initialize(app, env)
           @app = app
-          @logger = Log4r::Logger.new("vagrant_vcloud::action::resume")
+          @logger = Log4r::Logger.new('vagrant_vcloud::action::resume')
         end
 
         def call(env)
-
           cfg = env[:machine].provider_config
           cnx = cfg.vcloud_cnx.driver
 
-          vAppId = env[:machine].get_vapp_id
-          vmId = env[:machine].id
-          vmName = env[:machine].name
-
-          env[:ui].info("Powering on VM...")
-          task_id = cnx.poweron_vm(vmId)
-          wait = cnx.wait_task_completion(task_id)
+          vm_id = env[:machine].id
 
-          true
+          env[:ui].info('Powering on VM...')
+          task_id = cnx.poweron_vm(vm_id)
+          cnx.wait_task_completion(task_id)
 
           @app.call env
         end

data/lib/vagrant-vcloud/action/suspend.rb

@@ -1,29 +1,21 @@
-require "i18n"
-
 module VagrantPlugins
   module VCloud
     module Action
       class Suspend
-
         def initialize(app, env)
           @app = app
-          @logger = Log4r::Logger.new("vagrant_vcloud::action::suspend")
+          @logger = Log4r::Logger.new('vagrant_vcloud::action::suspend')
         end
 
         def call(env)
-
           cfg = env[:machine].provider_config
           cnx = cfg.vcloud_cnx.driver
 
-          vAppId = env[:machine].get_vapp_id
-          vmId = env[:machine].id
-          vmName = env[:machine].name
-
-          env[:ui].info("Suspending VM...")
-          task_id = cnx.suspend_vm(vmId)
-          wait = cnx.wait_task_completion(task_id)
+          vm_id = env[:machine].id
 
-          true
+          env[:ui].info('Suspending VM...')
+          task_id = cnx.suspend_vm(vm_id)
+          cnx.wait_task_completion(task_id)
 
           @app.call env
         end

data/lib/vagrant-vcloud/action/sync_folders.rb

@@ -1,57 +1,73 @@
 # The MIT License (MIT)
 # Copyright (c) 2013 Mitchell Hashimoto
 
-# 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:
+# 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.
+# 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.
 
-require "log4r"
-require "vagrant/util/subprocess"
-require "vagrant/util/scoped_hash_override"
-require "vagrant/util/which"
+require 'vagrant/util/subprocess'
+require 'vagrant/util/scoped_hash_override'
+require 'vagrant/util/which'
 
 module VagrantPlugins
   module VCloud
     module Action
+      # This class syncs Vagrant folders using RSYNC, this code has been ported
+      # from vagrant-aws (https://github.com/mitchellh/vagrant-aws)
       class SyncFolders
         include Vagrant::Util::ScopedHashOverride
 
         def initialize(app, env)
           @app    = app
-          @logger = Log4r::Logger.new("vagrant_vcloud::action::sync_folders")
+          @logger = Log4r::Logger.new('vagrant_vcloud::action::sync_folders')
         end
 
         def call(env)
           @app.call(env)
 
-          ### COMPLETELY REDO USING UNISON!!!!
-
           ssh_info = env[:machine].ssh_info
 
+          unless Vagrant::Util::Which.which('rsync')
+            env[:ui].warn(
+              I18n.t(
+                'vagrant_vcloud.sync.rsync_not_found_warning',
+                :side => 'host'
+              )
+            )
+            return
+          end
+
+          if env[:machine].communicate.execute('which rsync',
+                                               :error_check => false) != 0
+            env[:ui].warn(
+              I18n.t(
+                'vagrant_vcloud.sync.rsync_not_found_warning',
+                :side => 'guest'
+              )
+            )
+            return
+          end
+
           env[:machine].config.vm.synced_folders.each do |id, data|
-            data = scoped_hash_override(data, :vcloud)
+            data = scoped_hash_override(data, :vCloud)
 
             # Ignore disabled shared folders
             next if data[:disabled]
 
-            unless Vagrant::Util::Which.which('rsync')
-              env[:ui].warn(I18n.t('vagrant_vcloud.rsync_not_found_warning'))
-              break
-            end
-
             hostpath  = File.expand_path(data[:hostpath], env[:root_path])
             guestpath = data[:guestpath]
 
@@ -61,56 +77,74 @@ module VagrantPlugins
 
             # on windows rsync.exe requires cygdrive-style paths
             if Vagrant::Util::Platform.windows?
-              hostpath = hostpath.gsub(/^(\w):/) { "/cygdrive/#{$1}" }
+              hostpath = hostpath.gsub(/^(\w):/) { "/cygdrive/\1" }
             end
 
-            env[:ui].info(I18n.t("vagrant_vcloud.rsync_folder",
-                                :hostpath => hostpath,
-                                :guestpath => guestpath))
+            env[:ui].info(
+              I18n.t(
+                'vagrant_vcloud.sync.rsync_folder',
+                :hostpath   => hostpath,
+                :guestpath  => guestpath
+              )
+            )
 
             # Create the host path if it doesn't exist and option flag is set
             if data[:create]
               begin
-                FileUtils::mkdir_p(hostpath)
+                FileUtils.mkdir_p(hostpath)
               rescue => err
                 raise Errors::MkdirError,
-                  :hostpath => hostpath,
-                  :err => err
+                      :hostpath => hostpath,
+                      :err      => err
               end
             end
 
             # Create the guest path
             env[:machine].communicate.sudo("mkdir -p '#{guestpath}'")
             env[:machine].communicate.sudo(
-              "chown #{ssh_info[:username]} '#{guestpath}'")
-              
-            # Since Vagrant 1.4 the private key path may be an array
-            ssh_key_paths = ssh_info[:private_key_path].is_a?(Array) ? ssh_info[:private_key_path] : [ ssh_info[:private_key_path] ]
-            ssh_keys = ssh_key_paths.map {|p| "-i '#{p}'"}.join(" ")
+              "chown -R #{ssh_info[:username]} '#{guestpath}'"
+            )
+
+            # collect rsync excludes specified :rsync_excludes=>['path1',...]
+            # in synced_folder options
+            excludes = [
+              '.vagrant/',
+              'Vagrantfile',
+              *Array(data[:rsync_excludes])
+            ].uniq
 
             # Rsync over to the guest path using the SSH info
             command = [
-              "rsync", "--verbose", "--archive", "-z",
-              "--exclude", ".vagrant/", "--exclude", "Vagrantfile",
-              "-e", "ssh -p #{ssh_info[:port]} -o StrictHostKeyChecking=no #{ssh_keys}",
-              hostpath,
-              "#{ssh_info[:username]}@#{ssh_info[:host]}:#{guestpath}"]
+              'rsync', '--verbose', '--archive', '-z',
+              *excludes.map { |e|['--exclude', e] }.flatten,
+              '-e', "ssh -p #{ssh_info[:port]} -o StrictHostKeyChecking=no " +
+              "#{ssh_key_options(ssh_info)}", hostpath,
+              "#{ssh_info[:username]}@#{ssh_info[:host]}:#{guestpath}"
+            ]
 
             # we need to fix permissions when using rsync.exe on windows, see
-            # http://stackoverflow.com/questions/5798807/rsync-permission-denied-created-directories-have-no-permissions
+            # http://stackoverflow.com/questions/5798807/rsync-permission-
+            # denied-created-directories-have-no-permissions
             if Vagrant::Util::Platform.windows?
-              command.insert(1, "--chmod", "ugo=rwX")
+              command.insert(1, '--chmod', 'ugo=rwX')
             end
 
             r = Vagrant::Util::Subprocess.execute(*command)
             if r.exit_code != 0
-              raise Errors::RsyncError,
-                :guestpath => guestpath,
-                :hostpath => hostpath,
-                :stderr => r.stderr
+              fail Errors::RsyncError,
+                   :guestpath => guestpath,
+                   :hostpath  => hostpath,
+                   :stderr    => r.stderr
             end
           end
         end
+
+        private
+
+        def ssh_key_options(ssh_info)
+          # Ensure that `private_key_path` is an Array (for Vagrant < 1.4)
+          Array(ssh_info[:private_key_path]).map { |path| "-i '#{path}' " }.join
+        end
       end
     end
   end

data/lib/vagrant-vcloud/action/unmap_port_forwardings.rb

@@ -1,6 +1,4 @@
-require "set"
-
-require "log4r"
+require 'set'
 
 module VagrantPlugins
   module VCloud
@@ -22,51 +20,51 @@ module VagrantPlugins
       #     to other host ports.
       #
       class UnmapPortForwardings
-
-
         def initialize(app, env)
           @app    = app
-          @logger = Log4r::Logger.new("vagrant_vcloud::action::unmap_port_forwardings")
+          @logger = Log4r::Logger.new(
+            'vagrant_vcloud::action::unmap_port_forwardings'
+          )
         end
 
         def call(env)
-          
           cfg = env[:machine].provider_config
           cnx = cfg.vcloud_cnx.driver
-          vmName = env[:machine].name
-          vAppId = env[:machine].get_vapp_id
+          vapp_id = env[:machine].get_vapp_id
+          vm_name = env[:machine].name
 
           cfg.org = cnx.get_organization_by_name(cfg.org_name)
           cfg.vdc_network_id = cfg.org[:networks][cfg.vdc_network_name]
 
-          @logger.debug("Getting vapp info...")
-          vm = cnx.get_vapp(vAppId)
-          myhash = vm[:vms_hash][vmName.to_sym]
+          @logger.debug('Getting vApp information...')
+          vm = cnx.get_vapp(vapp_id)
+          myhash = vm[:vms_hash][vm_name.to_sym]
 
-          @logger.debug("Getting port forwarding rules...")
-          rules = cnx.get_vapp_port_forwarding_rules(vAppId)
+          @logger.debug('Getting port forwarding rules...')
+          rules = cnx.get_vapp_port_forwarding_rules(vapp_id)
 
-          newRuleSet = rules.select { |h| !myhash[:vapp_scoped_local_id].include? h[:vapp_scoped_local_id] }
+          # FIXME: not familiar with this syntax (tsugliani)
+          new_rule_set = rules.select {
+            |h| !myhash[:vapp_scoped_local_id].include? h[:vapp_scoped_local_id]
+          }
 
-          @logger.debug("OUR NEW RULE SET, PURGED: #{newRuleSet}")
+          @logger.debug("OUR NEW RULE SET, PURGED: #{new_rule_set}")
 
-          removePorts = cnx.set_vapp_port_forwarding_rules(
-            vAppId,
-            "Vagrant-vApp-Net",
-            {
-              :fence_mode => "natRouted",
-              :parent_network => cfg.vdc_network_id,
-              :nat_policy_type => "allowTraffic",
-              :nat_rules => newRuleSet
-            })
+          remove_ports = cnx.set_vapp_port_forwarding_rules(
+            vapp_id,
+            'Vagrant-vApp-Net',
+            :fence_mode       => 'natRouted',
+            :parent_network   => cfg.vdc_network_id,
+            :nat_policy_type  => 'allowTraffic',
+            :nat_rules        => new_rule_set
+          )
 
-          wait = cnx.wait_task_completion(removePorts)
+          wait = cnx.wait_task_completion(remove_ports)
 
-          if !wait[:errormsg].nil?
-            raise Errors::ComposeVAppError, :message => wait[:errormsg]
+          unless wait[:errormsg].nil?
+            fail Errors::ComposeVAppError, :message => wait[:errormsg]
           end
 
-
           @app.call(env)
         end
       end

data/lib/vagrant-vcloud/command.rb

@@ -0,0 +1,186 @@
+require 'awesome_print'
+require 'terminal-table'
+
+module VagrantPlugins
+  module VCloud
+    class Command < Vagrant.plugin('2', :command)
+      def self.synopsis
+        'outputs status of the vCloud Director setup [vcloud provider only]'
+      end
+
+      def execute
+        options = {}
+        opts = OptionParser.new do |o|
+          o.banner = 'Usage: vagrant vcloud-status [--all]'
+
+          # We can probably extend this if needed for specific information
+          o.on('-a', '--all', 'Displays all available information') do |f|
+            options[:all] = true
+          end
+        end
+
+        @argv = parse_options(opts)
+        return unless @argv
+
+        # initialize some variables
+        vapp_id = nil
+        cfg = nil
+
+        # Go through the vagrant machines
+        with_target_vms(@argv) do |machine|
+
+          # FIXME/Bug: why does the provider switch to virtualbox when
+          # destroying VMs within the the vApp:
+          # .vagrant/machines/<machine>/virtualbox Cannot trace why this
+          # happens :-( (tsugliani)
+          if machine.provider_name != :vcloud
+            # Not a vCloud Director provider, exit with explicit error message
+            puts "#{machine.provider_name} provider is incompatible with " +
+                  'this command'
+            exit 1
+          end
+
+          # Force reloads on objects by fetching the ssh_info
+          machine.provider.ssh_info
+
+          # populate cfg & vApp Id for later use.
+          cfg = machine.provider_config
+          vapp_id = machine.get_vapp_id
+          break
+        end
+
+        # Set our handlers to the driver and objects
+        cnx = cfg.vcloud_cnx.driver
+        vapp = cnx.get_vapp(vapp_id)
+
+        organization = cnx.get_organization_by_name(cfg.org_name)
+        cfg.vdc_id = cnx.get_vdc_id_by_name(organization, cfg.vdc_name)
+
+        # Create a new table for the general information
+        table = Terminal::Table.new
+        table.title = "Vagrant vCloud Director Status : #{cfg.hostname}"
+
+        table << ['Organization Name', cfg.org_name]
+        table << ['Organization vDC Name', cfg.vdc_name]
+        table << ['Organization vDC ID', cfg.vdc_id]
+        table << ['Organization vDC Network Name', cfg.vdc_network_name]
+        table << ['Organization vDC Edge Gateway Name',
+                  cfg.vdc_edge_gateway] unless cfg.vdc_edge_gateway.nil?
+        table << ['Organization vDC Edge IP',
+                  cfg.vdc_edge_gateway_ip] unless cfg.vdc_edge_gateway_ip.nil?
+        table << :separator
+        table << ['vApp Name', vapp[:name]]
+        table << ['vAppID', vapp_id]
+
+        vapp[:vms_hash].each do |vm|
+          # This should be checked indivudually
+          # When 1 VM is destroyed, ID is still populated, should be cleaned.
+          table << ["-> #{vm[0]}", vm[1][:id]]
+        end
+
+        # Print the General Information Table
+        puts table
+
+        # Display Network information only if --all is passed to the cmd
+        if options[:all] == true
+
+          # FIXME: this needs to be fixed to accomodate the bridged scenario
+          # potentially showing only the assigned IPs in the VMs
+
+          vapp_edge_ip = cnx.get_vapp_edge_public_ip(vapp_id)
+          vapp_edge_rules = cnx.get_vapp_port_forwarding_rules(vapp_id)
+          edge_gateway_rules = cnx.get_edge_gateway_rules(cfg.vdc_edge_gateway,
+                                                          cfg.vdc_id)
+
+          # Create a new table for the network information
+          network_table = Terminal::Table.new
+          network_table.title = 'Vagrant vCloud Director Network Map'
+
+          network_table << ['VM Name', 'Destination NAT Mapping', 'Enabled']
+          network_table << :separator
+
+          # Fetching Destination NAT Rules for each vApp/Edge/VM/Mapping
+          edge_gateway_rules.each do |edge_gateway_rule|
+            vapp_edge_rules.each do |vapp_edge_rule|
+
+              # Only check DNAT and src/dst
+              if edge_gateway_rule[:rule_type] == 'DNAT' &&
+                 edge_gateway_rule[:original_ip] == cfg.vdc_edge_gateway_ip &&
+                 edge_gateway_rule[:translated_ip] == vapp_edge_ip
+
+                 # Loop on every VM in the vApp
+                vapp[:vms_hash].each do |vm|
+                  # Only Map valid vAppEdge scope to VM scope
+                  vm_scope = vm[1][:vapp_scoped_local_id]
+                  vapp_edge_scope = vapp_edge_rule[:vapp_scoped_local_id]
+
+                  if vm_scope == vapp_edge_scope
+
+                    # Generate DNAT Mappings for the valid machines
+                    # If rules don't match, you will not see them !
+                    network_table << [
+                      "#{vm[0]}",
+                      "#{cfg.vdc_edge_gateway_ip}:" +
+                      "#{vapp_edge_rule[:nat_external_port]}" +
+                      " -> #{vapp_edge_ip}:" +
+                      "#{vapp_edge_rule[:nat_external_port]}" +
+                      " -> #{vm[1][:addresses][0]}:" +
+                      "#{vapp_edge_rule[:nat_internal_port]}",
+                      edge_gateway_rule[:is_enabled]
+                    ]
+                  end
+                end
+              end
+            end
+          end
+
+          # Fetching Source NAT Rules for the vApp
+          network_table << :separator
+          network_table << ['Network Name', 'Source NAT Mapping', 'Enabled']
+          network_table << :separator
+
+          edge_gateway_rules.each do |edge_gateway_rule|
+            # Only check SNAT and src/dst
+            if edge_gateway_rule[:rule_type] == 'SNAT' &&
+               edge_gateway_rule[:original_ip] == vapp_edge_ip &&
+               edge_gateway_rule[:translated_ip] == cfg.vdc_edge_gateway_ip
+
+              network_table << [
+                edge_gateway_rule[:interface_name],
+                "#{vapp_edge_ip} -> #{cfg.vdc_edge_gateway_ip}",
+                edge_gateway_rule[:is_enabled]
+              ]
+            end
+          end
+
+          # Fetching Edge Gateway Firewall Rules
+          network_table << :separator
+          network_table << ['Rule# - Description', 'Firewall Rules', 'Enabled']
+          network_table << :separator
+          edge_gateway_rules.each do |edge_gateway_rule|
+            # Only add firewall rules
+            if edge_gateway_rule[:rule_type] == 'Firewall'
+              network_table << [
+                "#{edge_gateway_rule[:id]} - " +
+                "(#{edge_gateway_rule[:description]})",
+                "#{edge_gateway_rule[:policy]} " +
+                "SRC:#{edge_gateway_rule[:source_ip]}:" +
+                "#{edge_gateway_rule[:source_portrange]} to " +
+                "DST:#{edge_gateway_rule[:destination_ip]}:" +
+                "#{edge_gateway_rule[:destination_portrange]}",
+                "#{edge_gateway_rule[:is_enabled]}"
+              ]
+            end
+          end
+
+          # Print the Network Table
+          puts
+          puts network_table
+
+        end
+
+        0
+      end
+    end
+  end
+end