vagrant-vcloud 0.1.2 → 0.2.0

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

@@ -1,64 +1,53 @@
-require "log4r"
-
 module VagrantPlugins
   module VCloud
     module Action
       class ConnectVCloud
         def initialize(app, env)
           @app = app
-          @logger = Log4r::Logger.new("vagrant_vcloud::action::connect_vcloud")
+          @logger = Log4r::Logger.new('vagrant_vcloud::action::connect_vcloud')
         end
 
         def call(env)
           config = env[:machine].provider_config
 
-#          begin
-            # Avoid recreating a new session each time.
-            if !config.vcloud_cnx
-              @logger.info("Connecting to vCloud Director...")
+          if !config.vcloud_cnx
+            @logger.info('Connecting to vCloud Director...')
 
               @logger.debug("config.hostname    : #{config.hostname}")
               @logger.debug("config.username    : #{config.username}")
-              @logger.debug("config.password    : #{config.password}")
+              @logger.debug("config.password    : <hidden>")
               @logger.debug("config.org_name    : #{config.org_name}")
 
-              # Create the vcloud-rest connection object with the configuration 
-              # information.
-              config.vcloud_cnx = Driver::Meta.new(
-                config.hostname,
-                config.username,
-                config.password, 
-                config.org_name
-              )
-
-              @logger.info("Logging into vCloud Director...")
-              config.vcloud_cnx.login
-
-              # Check for the vCloud Director authentication token
-              if config.vcloud_cnx.driver.auth_key
-                @logger.info("Logged in successfully!")
-                @logger.debug(
-                  "x-vcloud-authorization=#{config.vcloud_cnx.driver.auth_key}"
-                )
-              else
-                @logger.info("Login failed in to #{config.hostname}.")
-                env[:ui].error("Login failed in to #{config.hostname}.")
-                raise
-              end
-            else
-              @logger.info("Already logged in, using current session")
+            # Create the vcloud-rest connection object with the configuration
+            # information.
+            config.vcloud_cnx = Driver::Meta.new(
+              config.hostname,
+              config.username,
+              config.password,
+              config.org_name
+            )
+
+            @logger.info('Logging into vCloud Director...')
+            config.vcloud_cnx.login
+
+            # Check for the vCloud Director authentication token
+            if config.vcloud_cnx.driver.auth_key
+              @logger.info('Logged in successfully!')
               @logger.debug(
-                  "x-vcloud-authorization=#{config.vcloud_cnx.driver.auth_key}"
+                "x-vcloud-authorization=#{config.vcloud_cnx.driver.auth_key}"
               )
+            else
+              @logger.info("Login failed in to #{config.hostname}.")
+              env[:ui].error("Login failed in to #{config.hostname}.")
+              raise
             end
-
-            @app.call env
-
-#          rescue Exception => e
-#            ### When bad credentials, we get here.
-#            @logger.debug("Couldn't connect to vCloud Director: #{e.inspect}")
-#            raise VagrantPlugins::VCloud::Errors::VCloudError, :message => e.message
-#          end
+          else
+            @logger.info('Already logged in, using current session')
+            @logger.debug(
+                "x-vcloud-authorization=#{config.vcloud_cnx.driver.auth_key}"
+            )
+          end
+          @app.call env
 
         end
       end

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

@@ -1,60 +1,65 @@
-require "i18n"
-
 module VagrantPlugins
   module VCloud
     module Action
       class Destroy
-
         def initialize(app, env)
           @app = app
-          @logger = Log4r::Logger.new("vagrant_vcloud::action::destroy")
+          @logger = Log4r::Logger.new('vagrant_vcloud::action::destroy')
         end
 
         def call(env)
-
           cfg = env[:machine].provider_config
           cnx = cfg.vcloud_cnx.driver
-          vAppId = env[:machine].get_vapp_id
-          vmId = env[:machine].id
+          vapp_id = env[:machine].get_vapp_id
+          vm_id = env[:machine].id
 
           cfg.org = cnx.get_organization_by_name(cfg.org_name)
           cfg.vdc_id = cnx.get_vdc_id_by_name(cfg.org, cfg.vdc_name)
 
-          testvApp = cnx.get_vapp(vAppId)
+          test_vapp = cnx.get_vapp(vapp_id)
 
-          @logger.debug("Number of VMs in the vApp: #{testvApp[:vms_hash].count}")
+          @logger.debug(
+            "Number of VMs in the vApp: #{test_vapp[:vms_hash].count}"
+          )
 
-          if testvApp[:vms_hash].count == 1
-            env[:ui].info("Single VM left in the vApp, destroying the vApp...")
+          if test_vapp[:vms_hash].count == 1
+            env[:ui].info('Single VM left in the vApp, destroying the vApp...')
 
             if cfg.vdc_edge_gateway_ip && cfg.vdc_edge_gateway
-              env[:ui].info("Removing NAT rules on [#{cfg.vdc_edge_gateway}] for IP [#{cfg.vdc_edge_gateway_ip}].")
-              @logger.debug("Deleting Edge Gateway rules - vdc id: #{cfg.vdc_id}")
-              edge_remove = cnx.remove_edge_gateway_rules(cfg.vdc_edge_gateway, cfg.vdc_id, cfg.vdc_edge_gateway_ip, vAppId)
+              env[:ui].info(
+                "Removing NAT rules on [#{cfg.vdc_edge_gateway}] " +
+                "for IP [#{cfg.vdc_edge_gateway_ip}]."
+              )
+              @logger.debug(
+                "Deleting Edge Gateway rules - vdc id: #{cfg.vdc_id}"
+              )
+              edge_remove = cnx.remove_edge_gateway_rules(
+                cfg.vdc_edge_gateway,
+                cfg.vdc_id,
+                cfg.vdc_edge_gateway_ip,
+                vapp_id
+              )
               cnx.wait_task_completion(edge_remove)
             end
 
-            env[:ui].info("Destroying vApp...")
-            vAppDeleteTask = cnx.delete_vapp(vAppId)
-            @logger.debug("vApp Delete task id #{vAppDeleteTask}")
-            cnx.wait_task_completion(vAppDeleteTask)
+            env[:ui].info('Destroying vApp...')
+            vapp_delete_task = cnx.delete_vapp(vapp_id)
+            @logger.debug("vApp Delete task id #{vapp_delete_task}")
+            cnx.wait_task_completion(vapp_delete_task)
 
-
-            # FIXME: Look into this.
-            ####env[:machine].provider.driver.delete
-            env[:machine].id=nil
-            env[:machine].vappid=nil
+            env[:machine].id = nil
+            env[:machine].vappid = nil
           else
-            env[:ui].info("Destroying VM...")
-            vmDeleteTask = cnx.delete_vm(vmId)
-            @logger.debug("VM Delete task id #{vmDeleteTask}")
-            cnx.wait_task_completion(vmDeleteTask)
-            env[:machine].id=nil
+            env[:ui].info('Destroying VM...')
+            vm_delete_task = cnx.delete_vm(vm_id)
+            @logger.debug("VM Delete task id #{vm_delete_task}")
+            cnx.wait_task_completion(vm_delete_task)
+
+            env[:machine].id = nil
           end
 
           @app.call env
         end
-
       end
     end
   end

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

@@ -4,14 +4,16 @@ module VagrantPlugins
       class DisconnectVCloud
         def initialize(app, env)
           @app = app
-          @logger = Log4r::Logger.new("vagrant_vcloud::action::disconnect_vcloud")
+          @logger = Log4r::Logger.new(
+            'vagrant_vcloud::action::disconnect_vcloud'
+          )
         end
 
         def call(env)
           begin
-           @logger.info("Disconnecting from vCloud Director...")
+            @logger.info('Disconnecting from vCloud Director...')
 
-            # Fetch the global vCloud Director connection handle            
+            # Fetch the global vCloud Director connection handle
             cnx = env[:machine].provider_config.vcloud_cnx.driver
 
             # Delete the current vCloud Director Session
@@ -19,11 +21,11 @@ module VagrantPlugins
 
             # If session key doesn't exist, we are disconnected
             if !cnx.auth_key
-              @logger.info("Disconnected from vCloud Director successfully!")
+              @logger.info('Disconnected from vCloud Director successfully!')
             end
 
           rescue Exception => e
-            #raise a properly namespaced error for Vagrant
+            # Raise a properly namespaced error for Vagrant
             raise Errors::VCloudError, :message => e.message
           end
         end

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

@@ -6,17 +6,16 @@ module VagrantPlugins
 
         def initialize(app, env)
           @app = app
-          @logger = Log4r::Logger.new("vagrant_vcloud::action::forward_ports")
+          @logger = Log4r::Logger.new('vagrant_vcloud::action::forward_ports')
         end
 
-        #--------------------------------------------------------------
-        # Execution
-        #--------------------------------------------------------------
         def call(env)
           @env = env
 
-          # Get the ports we're forwarding
-          env[:forwarded_ports] ||= compile_forwarded_ports(env[:machine].config)
+          # Get the ports we are forwarding
+          env[:forwarded_ports] ||= compile_forwarded_ports(
+            env[:machine].config
+          )
 
           forward_ports
 
@@ -28,34 +27,42 @@ module VagrantPlugins
 
           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 VM info...")
-          vm = cnx.get_vapp(vAppId)
-          vmInfo = vm[:vms_hash][vmName.to_sym]
+          # FIXME: why are we overriding this here ?
+          #        It's already been taken care during the initial
+          #        InventoryCheck. (tsugliani)
+          #
+          # cfg.org = cnx.get_organization_by_name(cfg.org_name)
+          # cfg.vdc_network_id = cfg.org[:networks][cfg.vdc_network_name]
 
+          @logger.debug('Getting VM info...')
+          vm = cnx.get_vapp(vapp_id)
+          vm_info = vm[:vms_hash][vm_name.to_sym]
 
           @env[:forwarded_ports].each do |fp|
+            # FIXME: Useless variable assignement 'message_attributes'
+            # (tsugliani)
             message_attributes = {
-              :guest_port => fp.guest_port,
-              :host_port => fp.host_port
+              :guest_port   => fp.guest_port,
+              :host_port    => fp.host_port
             }
 
-            @env[:ui].info("Forwarding Ports: VM port #{fp.guest_port} -> vShield Edge port #{fp.host_port}")
+            @env[:ui].info(
+              "Forwarding Ports: VM port #{fp.guest_port} -> " +
+              "vShield Edge port #{fp.host_port}"
+            )
 
             # Add the options to the ports array to send to the driver later
             ports << {
-              :guestip   => fp.guest_ip,
-              :nat_internal_port => fp.guest_port,
-              :hostip    => fp.host_ip,
-              :nat_external_port  => fp.host_port,
-              :name      => fp.id,
-              :nat_protocol  => fp.protocol.upcase,
-              :vapp_scoped_local_id => vmInfo[:vapp_scoped_local_id]
+              :guestip                => fp.guest_ip,
+              :nat_internal_port      => fp.guest_port,
+              :hostip                 => fp.host_ip,
+              :nat_external_port      => fp.host_port,
+              :name                   => fp.id,
+              :nat_protocol           => fp.protocol.upcase,
+              :vapp_scoped_local_id   => vm_info[:vapp_scoped_local_id]
             }
           end
 
@@ -65,18 +72,18 @@ module VagrantPlugins
             @logger.debug("Current network id #{cfg.vdc_network_id}")
 
             ### Here we apply the nat_rules to the vApp we just built
-
-            addports = cnx.add_vapp_port_forwarding_rules(
-              vAppId,
-              "Vagrant-vApp-Net",
+            add_ports = cnx.add_vapp_port_forwarding_rules(
+              vapp_id,
+              'Vagrant-vApp-Net',
               {
-                :fence_mode => "natRouted",
-                :parent_network => cfg.vdc_network_id,
-                :nat_policy_type => "allowTraffic",
-                :nat_rules => ports
-              })
-
-            wait = cnx.wait_task_completion(addports)
+                :fence_mode       => 'natRouted',
+                :parent_network   => cfg.vdc_network_id,
+                :nat_policy_type  => 'allowTraffic',
+                :nat_rules        => ports
+              }
+            )
+
+            wait = cnx.wait_task_completion(add_ports)
 
             if !wait[:errormsg].nil?
               raise Errors::ComposeVAppError, :message => wait[:errormsg]

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

@@ -1,5 +1,4 @@
-require "set"
-require "log4r"
+require 'set'
 
 module VagrantPlugins
   module VCloud
@@ -21,14 +20,15 @@ module VagrantPlugins
       #     to other host ports.
       #
       class HandleNATPortCollisions
-
         def initialize(app, env)
           @app    = app
-          @logger = Log4r::Logger.new("vagrant_vcloud::action::handle_port_collisions")
+          @logger = Log4r::Logger.new(
+            'vagrant_vcloud::action::handle_port_collisions'
+          )
         end
 
         def call(env)
-          @logger.info("Detecting any forwarded port collisions...")
+          @logger.info('Detecting any forwarded port collisions...')
 
           # Determine a list of usable ports for repair
           usable_ports = Set.new(env[:machine].config.vm.usable_port_range)
@@ -40,15 +40,10 @@ module VagrantPlugins
 
           cfg = env[:machine].provider_config
           cnx = cfg.vcloud_cnx.driver
-          vmName = env[:machine].name
-          vAppId = env[:machine].get_vapp_id
-
-          @logger.debug("Getting vapp info...")
-          vm = cnx.get_vapp(vAppId)
-          myhash = vm[:vms_hash][vmName.to_sym]
+          vapp_id = env[:machine].get_vapp_id
 
-          @logger.debug("Getting port forwarding rules...")
-          rules = cnx.get_vapp_port_forwarding_external_ports(vAppId)
+          @logger.debug('Getting port forwarding rules...')
+          rules = cnx.get_vapp_port_forwarding_external_ports(vapp_id)
 
           # Pass two, detect/handle any collisions
           with_forwarded_ports(env) do |options|
@@ -73,7 +68,10 @@ module VagrantPlugins
 
                 # If the port is in use, then we can't use this either...
                 if rules.include?(repaired_port)
-                  @logger.info("Repaired port also in use: #{repaired_port}. Trying another...")
+                  @logger.info(
+                    "Repaired port also in use: #{repaired_port}." +
+                    'Trying another...'
+                  )
                   next
                 end
 
@@ -84,21 +82,27 @@ module VagrantPlugins
               # If we have no usable ports then we can't repair
               if !repaired_port && usable_ports.empty?
                 raise Errors::ForwardPortAutolistEmpty,
-                  :vm_name    => env[:machine].name,
-                  :guest_port => guest_port.to_s,
-                  :host_port  => host_port.to_s
+                      :vm_name    => env[:machine].name,
+                      :guest_port => guest_port.to_s,
+                      :host_port  => host_port.to_s
               end
 
               # Modify the args in place
               options[:host] = repaired_port
 
-              @logger.info("Repaired FP collision: #{host_port} to #{repaired_port}")
+              @logger.info(
+                "Repaired FP collision: #{host_port} to #{repaired_port}"
+              )
 
               # Notify the user
-              env[:ui].info(I18n.t("vagrant.actions.vm.forward_ports.fixed_collision",
-                                   :host_port  => host_port.to_s,
-                                   :guest_port => guest_port.to_s,
-                                   :new_port   => repaired_port.to_s))
+              env[:ui].info(
+                I18n.t(
+                  'vagrant.actions.vm.forward_ports.fixed_collision',
+                  :host_port  => host_port.to_s,
+                  :guest_port => guest_port.to_s,
+                  :new_port   => repaired_port.to_s
+                )
+              )
             end
           end
 

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

@@ -1,73 +1,79 @@
-require "etc"
-require "log4r"
+require 'etc'
 
 module VagrantPlugins
   module VCloud
     module Action
       class InventoryCheck
-
         def initialize(app, env)
           @app = app
-          @logger = Log4r::Logger.new("vagrant_vcloud::action::inventory_check")
+          @logger = Log4r::Logger.new('vagrant_vcloud::action::inventory_check')
         end
 
         def call(env)
           vcloud_check_inventory(env)
-            
+
           @app.call env
         end
 
         def vcloud_upload_box(env)
-
           cfg = env[:machine].provider_config
           cnx = cfg.vcloud_cnx.driver
 
-          boxDir = env[:machine].box.directory.to_s
-          boxFile = env[:machine].box.name.to_s
+          box_dir = env[:machine].box.directory.to_s
+          box_file = env[:machine].box.name.to_s
 
-          boxOVF = "#{boxDir}/#{boxFile}.ovf"
+          box_ovf = "#{box_dir}/#{box_file}.ovf"
 
-          # Still relying on ruby-progressbar because report_progress basically sucks.
-
-          @logger.debug("OVF File: #{boxOVF}")
-          uploadOVF = cnx.upload_ovf(
+          # Still relying on ruby-progressbar because report_progress
+          # basically sucks.
+          @logger.debug("OVF File: #{box_ovf}")
+          upload_ovf = cnx.upload_ovf(
             cfg.vdc_id,
             env[:machine].box.name.to_s,
-            "Vagrant Box",
-            boxOVF,
+            'Vagrant Box',
+            box_ovf,
             cfg.catalog_id,
             {
-              :progressbar_enable => true
-              # FIXME: export chunksize as a parameter and lower the default to 1M.
-              #:chunksize => 262144
+              :progressbar_enable => true,
+              :chunksize => (cfg.upload_chunksize || 1_048_576)
             }
           )
 
-          env[:ui].info("Adding [#{env[:machine].box.name.to_s}] to Catalog [#{cfg.catalog_name}]")
-          addOVFtoCatalog = cnx.wait_task_completion(uploadOVF)
+          env[:ui].info(
+            "Adding [#{env[:machine].box.name.to_s}] to " +
+            "Catalog [#{cfg.catalog_name}]"
+          )
+          add_ovf_to_catalog = cnx.wait_task_completion(upload_ovf)
 
-          if !addOVFtoCatalog[:errormsg].nil?
-            raise Errors::CatalogAddError, :message => addOVFtoCatalog[:errormsg]
+          unless add_ovf_to_catalog[:errormsg].nil?
+            fail Errors::CatalogAddError,
+                 :message => add_ovf_to_catalog[:errormsg]
           end
 
           # Retrieve catalog_item ID
-          cfg.catalog_item = cnx.get_catalog_item_by_name(cfg.catalog_id, env[:machine].box.name.to_s)
-
+          cfg.catalog_item = cnx.get_catalog_item_by_name(
+            cfg.catalog_id,
+            env[:machine].box.name.to_s
+          )
         end
 
         def vcloud_create_catalog(env)
           cfg = env[:machine].provider_config
           cnx = cfg.vcloud_cnx.driver
 
-          catalogCreation = cnx.create_catalog(cfg.org_id, cfg.catalog_name, "Created by #{Etc.getlogin} running on #{Socket.gethostname.downcase} using vagrant-vcloud on #{Time.now.strftime("%B %d, %Y")}")
-          cnx.wait_task_completion(catalogCreation[:task_id])
-
-          @logger.debug("Catalog Creation result: #{catalogCreation.inspect}")
+          catalog_creation = cnx.create_catalog(
+            cfg.org_id,
+            cfg.catalog_name,
+            "Created by #{Etc.getlogin} " +
+            "running on #{Socket.gethostname.downcase} " +
+            "using vagrant-vcloud on #{Time.now.strftime("%B %d, %Y")}"
+          )
+          cnx.wait_task_completion(catalog_creation[:task_id])
 
+          @logger.debug("Catalog Creation result: #{catalog_creation.inspect}")
           env[:ui].info("Catalog [#{cfg.catalog_name}] successfully created.")
 
-          cfg.catalog_id = catalogCreation[:catalog_id]
-
+          cfg.catalog_id = catalog_creation[:catalog_id]
         end
 
         def vcloud_check_inventory(env)
@@ -83,72 +89,93 @@ module VagrantPlugins
           cfg.vdc_id = cnx.get_vdc_id_by_name(cfg.org, cfg.vdc_name)
 
           cfg.catalog = cnx.get_catalog_by_name(cfg.org, cfg.catalog_name)
-          
           cfg.catalog_id = cnx.get_catalog_id_by_name(cfg.org, cfg.catalog_name)
 
           if cfg.catalog_id.nil?
             env[:ui].warn("Catalog [#{cfg.catalog_name}] does not exist!")
 
             user_input = env[:ui].ask(
-              "Would you like to create the [#{cfg.catalog_name}] catalog?\nChoice (yes/no): "
+              "Would you like to create the [#{cfg.catalog_name}] catalog?\n" +
+              'Choice (yes/no): '
             )
 
-            if user_input.downcase == "yes" || user_input.downcase == "y" 
+            if user_input.downcase == 'yes' || user_input.downcase == 'y'
               vcloud_create_catalog(env)
             else
-              env[:ui].error("Catalog not created, exiting...")
+              env[:ui].error('Catalog not created, exiting...')
 
               # FIXME: wrong error message
-              raise VagrantPlugins::VCloud::Errors::VCloudError, 
-                    :message => "Catalog not available, exiting..."
+              raise VagrantPlugins::VCloud::Errors::VCloudError,
+                    :message => 'Catalog not available, exiting...'
 
             end
           end
 
-          
-          @logger.debug("Getting catalog item with cfg.catalog_id: [#{cfg.catalog_id}] and machine name [#{env[:machine].box.name.to_s}]")
-          cfg.catalog_item = cnx.get_catalog_item_by_name(cfg.catalog_id, env[:machine].box.name.to_s)
+          @logger.debug(
+            "Getting catalog item with cfg.catalog_id: [#{cfg.catalog_id}] " +
+            "and machine name [#{env[:machine].box.name.to_s}]"
+          )
+          cfg.catalog_item = cnx.get_catalog_item_by_name(
+            cfg.catalog_id,
+            env[:machine].box.name.to_s
+          )
+
           @logger.debug("Catalog item is now #{cfg.catalog_item}")
-          cfg.vdc_network_id = cfg.org[:networks][cfg.vdc_network_name]
 
+          # This only works with Org Admin role or higher
+          cfg.vdc_network_id = cfg.org[:networks][cfg.vdc_network_name]
+          if !cfg.vdc_network_id
+            # TEMP FIX: permissions issues at the Org Level for vApp authors
+            #           to "view" Org vDC Networks but they can see them at the
+            #           Organization vDC level (tsugliani)
+            cfg.vdc_network_id = cfg.vdc[:networks][cfg.vdc_network_name]
+            if !cfg.vdc_network_id
+              raise 'vCloud User credentials has insufficient privileges'
+            end
+          end
 
           # Checking Catalog mandatory requirements
           if !cfg.catalog_id
             @logger.info("Catalog [#{cfg.catalog_name}] STILL does not exist!")
 
               # FIXME: wrong error message
-              raise VagrantPlugins::VCloud::Errors::VCloudError, 
-                    :message => "Catalog not available, exiting..."
+              raise VagrantPlugins::VCloud::Errors::VCloudError,
+                    :message => 'Catalog not available, exiting...'
 
           else
             @logger.info("Catalog [#{cfg.catalog_name}] exists")
           end
 
           if !cfg.catalog_item
-            env[:ui].warn("Catalog item [#{env[:machine].box.name.to_s}] in Catalog [#{cfg.catalog_name}] does not exist!")
+            env[:ui].warn(
+              "Catalog item [#{env[:machine].box.name.to_s}] " +
+              "in Catalog [#{cfg.catalog_name}] does not exist!"
+            )
 
             user_input = env[:ui].ask(
-              "Would you like to upload the [#{env[:machine].box.name.to_s}] box to "\
-              "[#{cfg.catalog_name}] Catalog?\nChoice (yes/no): "
+              "Would you like to upload the [#{env[:machine].box.name.to_s}] " +
+              "box to [#{cfg.catalog_name}] Catalog?\n" +
+              'Choice (yes/no): '
             )
 
-            if user_input.downcase == "yes" || user_input.downcase == "y" 
+            if user_input.downcase == 'yes' || user_input.downcase == 'y'
               env[:ui].info("Uploading [#{env[:machine].box.name.to_s}]...")
               vcloud_upload_box(env)
             else
-              env[:ui].error("Catalog item not available, exiting...")
+              env[:ui].error('Catalog item not available, exiting...')
 
               # FIXME: wrong error message
-              raise VagrantPlugins::VCloud::Errors::VCloudError, 
-                    :message => "Catalog item not available, exiting..."
-
+              raise VagrantPlugins::VCloud::Errors::VCloudError,
+                    :message => 'Catalog item not available, exiting...'
             end
 
           else
-            @logger.info("Using catalog item [#{env[:machine].box.name.to_s}] in Catalog [#{cfg.catalog_name}]...")
+            @logger.info(
+              "Using catalog item [#{env[:machine].box.name.to_s}] " +
+              "in Catalog [#{cfg.catalog_name}]..."
+            )
           end
         end
-
       end
     end
   end