secured-cloud-vagrant 1.0.0

data/lib/secured-cloud-vagrant/actions/power_off.rb

@@ -0,0 +1,22 @@
+require "log4r"
+
+require_relative "power_vm"
+
+module VagrantPlugins
+	module SecuredCloud
+		module Action
+		
+			# This can be used with "Call" built-in to check if the machine
+			# is created and branch in the middleware.
+			class PowerOff < PowerVm
+					  
+				def initialize(app, env)
+					env[:ui].info(I18n.t("secured_cloud_vagrant.info.powering_off"))
+					super(app, env, "off")
+				end
+				
+			end
+			
+		end
+	end
+end

data/lib/secured-cloud-vagrant/actions/power_on.rb

@@ -0,0 +1,22 @@
+require "log4r"
+
+require_relative "power_vm"
+
+module VagrantPlugins
+	module SecuredCloud
+		module Action
+		
+			# This can be used with "Call" built-in to check if the machine
+			# is created and branch in the middleware.
+			class PowerOn < PowerVm
+		  
+				def initialize(app, env)
+					env[:ui].info(I18n.t("secured_cloud_vagrant.info.powering_on"))
+					super(app, env, "on")
+				end
+				
+			end
+			
+		end
+	end
+end

data/lib/secured-cloud-vagrant/actions/power_vm.rb

@@ -0,0 +1,100 @@
+require "log4r"
+require "secured_cloud_api_client"
+
+module VagrantPlugins
+  module SecuredCloud
+    module Action
+      # This can be used with "Call" built-in to check if the machine
+      # is created and branch in the middleware.
+      class PowerVm
+        def initialize(app, env, powerStatus)
+          @app = app
+          @machine = env[:machine]
+          @powerStatus = powerStatus
+          @logger = Log4r::Logger.new('vagrant::secured_cloud::action::power_vm')
+        end
+
+        def call(env)
+
+          @logger.debug("Powering #{@powerStatus.upcase} VM ...")
+
+          vm_resource_url = @machine.id
+
+          if !vm_resource_url.nil? && !vm_resource_url.empty?
+
+            # Create a Secured Cloud Connection instance to connect tot he SecuredCloud API
+            authInfo = @machine.provider_config.auth
+            sc_connection = SecuredCloudConnection.new(authInfo.url, authInfo.applicationKey, authInfo.sharedSecret)
+
+            begin
+
+              # Send request to power VM
+              response = SecuredCloudRestClient.powerVM(sc_connection, vm_resource_url, @powerStatus)
+
+              #Monitor the transaction.
+              if (response[0] == "202")
+
+                #Task successful.
+                taskResource = response[1]
+                taskStatus = SecuredCloudRestClient::getTaskStatus(sc_connection, taskResource)
+
+                @logger.info("Task Status:\n#{taskStatus.get_details()}")
+
+                while ((taskStatus.instance_variable_get(:@requestStateEnum) == nil) || (taskStatus.instance_variable_get(:@requestStateEnum) == "OPEN")) do
+                  sleep(20)
+                  taskStatus = SecuredCloudRestClient.getTaskStatus(sc_connection, taskResource)
+                  env[:ui].info(I18n.t("secured_cloud_vagrant.info.task_status", :percentage => taskStatus.get_percentage_completed, 
+                    :task_desc => taskStatus.get_latest_task_description))
+                  @logger.info("Task Status:\n#{taskStatus.get_details()}")
+                end
+
+                if(taskStatus.get_result.nil?)
+
+                  #Task unsuccessful.
+                  @logger.debug("VM Power #{@powerStatus.upcase} failed with the following error:\n#{taskStatus.get_error_code}: #{taskStatus.get_error_message}")
+
+                  error_code = (taskStatus.get_error_code.nil?) ? "" : "#{taskStatus.get_error_code} "
+                  error_message = (taskStatus.get_error_message.nil?) ? I18n.t('secured_cloud_vagrant.errors.internal_server_error') : 
+                    error_code + taskStatus.get_error_message
+                  
+                  env[:ui].error(I18n.t("secured_cloud_vagrant.errors.powering_vm", :power_status => @powerStatus.upcase,
+                    :vm_name => env[:vm_name], :error_message => error_message))
+
+                else
+                  
+                  # Task successful
+                  @logger.debug("VM '#{env[:machine].id}' has been powered #{@powerStatus.upcase}")
+                  env[:ui].info(I18n.t("secured_cloud_vagrant.info.success.power_vm", :power_status => @powerStatus.upcase,
+                    :vm_name => env[:vm_name]))
+
+                end
+
+              else
+
+              #Task unsuccessful.
+                @logger.debug("VM Power #{@powerStatus.upcase} failed with the following error:\n#{response}")
+
+                error_message = (response[2].nil?) ? I18n.t('secured_cloud_vagrant.errors.internal_server_error') : response[2]
+                env[:ui].error(I18n.t("secured_cloud_vagrant.errors.powering_vm", :power_status => @powerStatus.upcase,
+                  :vm_name => env[:vm_name], :error_message => error_message))
+                
+              end
+
+            rescue Errno::ETIMEDOUT
+              env[:ui].error(I18n.t("secured_cloud_vagrant.errors.request_timed_out", :request => "power #{@powerStatus} VM '#{env[:vm_name]}'"))
+            rescue Exception => e
+              env[:ui].error(I18n.t("secured_cloud_vagrant.errors.generic_error", :error_message => e.message))
+            end
+
+          else
+            @logger.debug("No VM found to be powered #{@powerStatus.upcase}")
+          end
+
+          @app.call(env)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/secured-cloud-vagrant/actions/read_ssh_info.rb

@@ -0,0 +1,148 @@
+require "log4r"
+require "secured_cloud_api_client"
+
+module VagrantPlugins
+  module SecuredCloud
+    module Action
+      # This can be used with "Call" built-in to check if the machine
+      # is created and branch in the middleware.
+      class ReadSshInfo
+        
+        
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @logger = Log4r::Logger.new('vagrant::secured_cloud::action::read_ssh_info')
+        end
+
+        def call(env)
+
+          @logger.debug("Reading SSH info for VM #{env[:vm_name]} ...")
+          env[:vm_conn_info] = read_ssh_info(env)
+
+          @app.call(env)
+        end
+
+        def read_ssh_info(env)
+
+          # If the VM ID is not in the environment return null
+          if @machine.id.nil? || @machine.id.empty?
+            @logger.error("VM has not yet been created")
+            return nil
+          end
+
+          # Initialize the public IP, port and username to those defined in the Vagrantfile
+          publicIp = @machine.config.ssh.host
+          port = @machine.config.ssh.port
+          username = @machine.config.ssh.username
+
+          # If they are all defined return those values
+          if(!publicIp.nil? && !port.nil? && !username.nil?)
+            return { :host => publicIp, :port => port, :username => username, :private_key_path => nil }
+          end
+
+          begin
+
+            # Create a Secured Cloud Connection instance to connect tot he SecuredCloud API
+            authInfo = @machine.provider_config.auth
+            @sc_connection = SecuredCloudConnection.new(authInfo.url, authInfo.applicationKey, authInfo.sharedSecret)
+  
+            # Get the VM details
+            virtualMachine = SecuredCloudRestClient.getVMDetails(@sc_connection, @machine.id)
+
+            # If the VM is not found return null
+            if virtualMachine.nil?
+              @logger.error("VM '#{@machine.id}' not found")
+              return nil
+            end
+
+            # Get a public IP assigned to the VM if it is not nil
+            if publicIp.nil?
+
+              publicIp = get_public_ip(virtualMachine)
+
+              # If no public IP has been found yet return nil and show an error message
+              if publicIp.nil?
+                @logger.error("Cannot connect to a private VM")
+                env[:ui].warn(I18n.t('secured_cloud_vagrant.warnings.no_public_ips', :vm_name => virtualMachine.get_name))
+                return nil
+              end
+
+            end
+
+            # Get the username to connect to the VM
+            if username.nil?
+
+              username = get_username(virtualMachine)
+
+              if(username.nil?)
+                @logger.warn("No username could be determined to SSH to the VM.")
+              end
+            end
+
+            # If the port is not defined set it to 22
+            port = 22 if port.nil?
+
+            return { :host => publicIp, :port => port, :username => username, :private_key_path => nil }
+
+          rescue Errno::ETIMEDOUT
+            env[:ui].error(I18n.t('secured_cloud_vagrant.errors.request_timed_out', :request => "get the SSH information for VM '#{virtualMachine.get_name}'"))
+          rescue Exception => e
+            env[:ui].error(I18n.t("secured_cloud_vagrant.errors.generic_error", :error_message => e.message))
+          end
+
+        end
+
+        # Returns a public IP which is assigned to the VM
+        def get_public_ip(virtualMachine)
+
+          publicIp = nil
+
+          # Process the IP mappings of the VM
+          if !virtualMachine.get_ip_mappings.nil?
+            virtualMachine.get_ip_mappings.each do |ipMapping|
+              
+              if !ipMapping.get_public_ips.nil?
+                publicIp = ipMapping.get_public_ips[0]
+                @logger.debug("Public IP to SSH to VM: #{publicIp}")
+                break
+              end
+              
+            end
+          end
+
+          return publicIp
+          
+        end
+        
+
+        # Returns the username to SSH to the VM
+        def get_username(virtualMachine)
+
+          username = nil
+
+          # Get username of VM
+          osTemplateUrl = virtualMachine.get_os_template_resource_url
+
+          if !osTemplateUrl.nil?
+
+            osTemplate = SecuredCloudRestClient.getOsTemplateDetails(@sc_connection, osTemplateUrl)
+
+            if osTemplate.nil?
+              @logger.error("OsTemplate '#{osTemplateUrl}' not found")
+              return nil
+            end
+
+            username = osTemplate.get_administrator_username
+            @logger.debug("Username to connect to VM: #{username}")
+
+          end
+
+          return username
+        end
+
+      end
+
+    end
+  end
+end

data/lib/secured-cloud-vagrant/actions/reboot.rb

@@ -0,0 +1,98 @@
+require "log4r"
+require "secured_cloud_api_client"
+
+module VagrantPlugins
+  module SecuredCloud
+    module Action
+      # This can be used with "Call" built-in to check if the machine
+      # is created and branch in the middleware.
+      class Reboot
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @logger = Log4r::Logger.new('vagrant::secured_cloud::action::reboot_vm')
+        end
+
+        def call(env)
+
+          @logger.debug("Rebooting the VM ...")
+          env[:ui].info(I18n.t("secured_cloud_vagrant.info.reloading"))
+
+          vm_resource_url = @machine.id
+
+          if !vm_resource_url.nil? && !vm_resource_url.empty?
+
+            begin
+
+              # Create a Secured Cloud Connection instance to connect tot he SecuredCloud API
+              authInfo = @machine.provider_config.auth
+              sc_connection = SecuredCloudConnection.new(authInfo.url, authInfo.applicationKey, authInfo.sharedSecret)
+
+              # Send request to reboot VM
+              response = SecuredCloudRestClient.rebootVM(sc_connection, vm_resource_url)
+
+              # Monitor the transaction.
+              if (response[0] == "202")
+
+                #Task successful.
+                taskResource = response[1]
+                taskStatus = SecuredCloudRestClient::getTaskStatus(sc_connection, taskResource)
+
+                @logger.info("Task Status:\n#{taskStatus.get_details()}")
+
+                while ((taskStatus.instance_variable_get(:@requestStateEnum) == nil) || (taskStatus.instance_variable_get(:@requestStateEnum) == "OPEN")) do
+                  sleep(20)
+                  taskStatus = SecuredCloudRestClient.getTaskStatus(sc_connection, taskResource)
+                  env[:ui].info(I18n.t('secured_cloud_vagrant.info.task_status', :percentage => taskStatus.get_percentage_completed, 
+                    :task_desc => taskStatus.get_latest_task_description))
+                  @logger.info("Task Status:\n#{taskStatus.get_details()}")
+                end
+
+                if(taskStatus.get_result. nil?)
+
+                  #Task unsuccessful.
+                  @logger.debug("VM Reboot failed with the following error:\n#{taskStatus.get_error_code}: #{taskStatus.get_error_message}")
+
+                  error_code = (taskStatus.get_error_code.nil?) ? "" : "#{taskStatus.get_error_code} "
+                  error_message = (taskStatus.get_error_message.nil?) ? I18n.t('secured_cloud_vagrant.errors.internal_server_error') : 
+                    error_code + taskStatus.get_error_message
+                    
+                  env[:ui].error(I18n.t("secured_cloud_vagrant.errors.rebooting_vm", :vm_name => env[:vm_name], :error_message => error_message))
+
+                else
+                  
+                  # Task successful
+                  @logger.debug("VM '#{env[:machine].id}' has been rebooted")
+                  env[:ui].info(I18n.t("secured_cloud_vagrant.info.success.reboot_vm", :vm_name => env[:vm_name]))
+                  
+                end
+              else
+
+              #Task unsuccessful.
+                @logger.debug("VM Reboot failed with the following error:\n#{response}")
+
+                error_message = (response[2].nil?) ? I18n.t('secured_cloud_vagrant.errors.internal_server_error') : response[2]
+                env[:ui].error(I18n.t("secured_cloud_vagrant.errors.rebooting_vm", :vm_name => env[:vm_name], :error_message => error_message))
+                  
+              end
+
+            rescue Errno::ETIMEDOUT
+              env[:ui].error(I18n.t("secured_cloud_vagrant.errors.request_timed_out", :request => "reboot VM '#{env[:vm_name]}'"))
+            rescue Exception => e
+              env[:ui].error(I18n.t("secured_cloud_vagrant.errors.generic_error", :error_message => e.message))
+            end
+
+          else
+
+            @logger.debug("No VM found to be rebooted")
+
+          end
+
+          @app.call(env)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/secured-cloud-vagrant/actions/release_ips_confirm.rb

@@ -0,0 +1,25 @@
+require "vagrant/action/builtin/confirm"
+require "log4r"
+
+module VagrantPlugins
+	module SecuredCloud
+		module Action
+	
+			# This class asks the user to confirm whether the public IPs of 
+			# the VM managed by vagrant are to be released or put in the reserve 
+			# pool of the VDC. 
+			class ReleaseIpsConfirm < Confirm
+		  
+				def initialize(app, env)
+					
+					@logger = Log4r::Logger.new('vagrant::secured_cloud::action::release_ips_confirm')
+					@logger.debug("Confirming whether public IPs are to be released ...")
+					
+					message = I18n.t('secured_cloud_vagrant.commands.release_ips_confirmation')
+					super(app, env, message)
+				end
+			end
+	  
+		end
+	end
+end

data/lib/secured-cloud-vagrant/actions/wait_for_state.rb

@@ -0,0 +1,54 @@
+require "log4r"
+require "secured_cloud_api_client"
+
+module VagrantPlugins
+	module SecuredCloud
+		module Action
+		
+			# This can be used with "Call" built-in to check if the machine
+			# is created and branch in the middleware.
+			class WaitForState
+			
+				def initialize(app, env)
+					@app = app
+					@machine = env[:machine]
+					@logger = Log4r::Logger.new('vagrant::secured_cloud::action::wait_for_state')
+				end
+
+				def call(env)
+				
+					@logger.debug("Waiting for VM state to be powered OFF ...")
+					
+					vm_resource_url = @machine.id
+					
+					if !vm_resource_url.nil? && !vm_resource_url.empty?
+					
+						begin
+						  
+						  # Create a Secured Cloud Connection instance to connect tot he SecuredCloud API
+              authInfo = @machine.provider_config.auth
+              sc_connection = SecuredCloudConnection.new(authInfo.url, authInfo.applicationKey, authInfo.sharedSecret)
+						
+						  # Get the VM details and check the power status
+						 while (SecuredCloudRestClient.getVMDetails(sc_connection, vm_resource_url).get_power_status == "POWERED_ON") do
+							  
+							  # Sleep for 2 seconds
+                sleep 2
+							  
+							end
+							
+						rescue Errno::ETIMEDOUT
+							env[:ui].error(I18n.t("secured_cloud_vagrant.errors.request_timed_out", :request => "get the VM details"))
+            rescue Exception => e
+              env[:ui].error(I18n.t("secured_cloud_vagrant.errors.generic_error", :error_message => e.message))
+						end
+					end				
+					
+					@app.call(env)
+				end
+				
+			end
+			
+		end
+	end
+end