secured-cloud-vagrant 1.0.0

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

@@ -0,0 +1,142 @@
+require 'log4r'
+require 'secured_cloud_api_client'
+
+module VagrantPlugins
+  module SecuredCloud
+    module Action
+      class AssignPublicIps
+        def initialize(app, env)
+
+          @app = app
+          @machine = env[:machine]
+          @logger = Log4r::Logger.new('vagrant::secured_cloud::action::assign_public_ips')
+
+        end
+
+        def call(env)
+
+          @logger.debug("Assigning public IPs to VM with name #{@machine.provider_config.vm.name}")
+
+          if @machine.id.nil? || @machine.id.empty?
+            @logger.debug("The VM has not been created")
+            return
+          end
+
+          ipMappings = @machine.provider_config.vm.ipMappings
+
+          if ipMappings.nil? || ipMappings.empty?
+            @logger.debug("The VM has not been assigned any public IPs")
+          else
+
+            env[:ui].info(I18n.t("secured_cloud_vagrant.info.assigning_public_ips"))
+
+            # 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)
+
+            ipMappings.each do |ipMapping|
+
+              # Extract the parameters to pass to the assign public IP method
+              privateIp = ipMapping.privateIp
+              publicIpCount = ipMapping.newPublicIpCount
+              publicIpsFromReserved = ipMapping.publicIpsFromReserved
+
+              # Process the public IPs from global pool
+              publicIpCount.times do |n|
+                @logger.debug("Assigning public IP from global pool to private IP #{privateIp}")
+                assign_public_ip(privateIp, nil, env)
+              end
+
+              # Process the public IPs from reserve pool
+              if !publicIpsFromReserved.nil? && !publicIpsFromReserved.empty?
+
+                publicIpsFromReserved.each do |reservedIp|
+                  @logger.debug("Assigning public IP from reserve pool '#{reservedIp}' to private IP #{privateIp}")
+                  assign_public_ip(privateIp, reservedIp, env)
+                end
+
+              end
+
+            end
+
+          end
+
+          @app.call(env)
+
+        end
+
+        def assign_public_ip(private_ip, public_ip, env)
+
+          begin
+
+            # Call Rest Client to assign a public IP
+            response = SecuredCloudRestClient::assignPublicIpToVM(@sc_connection, @machine.id, public_ip, private_ip)
+
+            # 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("Public IP assignment 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.assigning_public_ip", :vm_name => env[:vm_name], :error_message => error_message))
+
+              else
+
+                # Task successful
+                if(public_ip.nil?)
+
+                  @logger.debug("VM #{env[:vm_name]} has been assigned a public IP from the global pool")
+                  env[:ui].info(I18n.t("secured_cloud_vagrant.info.success.assign_public_ip.global_pool", :vm_name => env[:vm_name]))
+                  
+                else
+                  
+                  @logger.debug("VM #{env[:vm_name]} has been assigned public IP '#{public_ip}' from the reserve pool")
+                  env[:ui].info(I18n.t("secured_cloud_vagrant.info.success.assign_public_ip.reserve_pool", :vm_name => env[:vm_name],
+                    :public_ip => public_ip))
+                end
+
+              end
+
+            else
+
+              # Task unsuccessful.
+              @logger.debug("Public IP assignment 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.assigning_public_ip", :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 => "assign a public IP"))
+          rescue Exception => e
+            env[:ui].error(I18n.t("secured_cloud_vagrant.errors.generic_error", :error_message => e.message))
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+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 CheckState
+			
+				def initialize(app, env)
+					@app = app
+					@machine = env[:machine]
+					@logger = Log4r::Logger.new('vagrant::secured_cloud::action::check_state')
+				end
+
+				def call(env)
+				
+					@logger.debug("Checking VM state ...")
+					
+					vm_resource_url = @machine.id
+					
+					if vm_resource_url.nil? || vm_resource_url.empty?
+						env[:machine_state] = :not_created
+					else
+					
+						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, vm_resource_url)
+								
+							# Set the VM name
+							env[:vm_name] = virtualMachine.get_name
+							@logger.debug("VM Name: '#{env[:vm_name]}'")
+								
+							# Get the VM power status
+							if (virtualMachine.get_power_status == "POWERED_OFF")
+								env[:machine_state] = :stopped
+							elsif (virtualMachine.get_power_status == "POWERED_ON")
+								env[:machine_state] = :active
+							end
+							
+							@logger.debug("State for VM #{vm_resource_url} is #{env[:machine_state]}")
+							
+						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

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

@@ -0,0 +1,112 @@
+require 'log4r'
+require 'secured_cloud_api_client'
+
+module VagrantPlugins
+	module SecuredCloud
+		module Action
+		
+			class Create
+								
+				def initialize(app, env)
+				
+					@app = app
+					@machine = env[:machine]
+					@logger = Log4r::Logger.new('vagrant::secured_cloud::action::create')
+					
+				end
+				
+				
+				def call(env)
+				
+					@logger.debug("Creating VM with name #{@machine.provider_config.vm.name}")
+					env[:ui].info(I18n.t("secured_cloud_vagrant.info.creating"))
+					
+					# 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)
+
+					# Extract the parameters to pass to the createVM method
+					vmName = @machine.provider_config.vm.name
+					vmDescription = @machine.provider_config.vm.description
+					vmStorageGB = @machine.provider_config.vm.storageGB
+					vmMemoryMB = @machine.provider_config.vm.memoryMB
+					vmVcpus = @machine.provider_config.vm.vcpus
+					vmPowerStatus = "POWERED_ON"
+					vmOsPassword = @machine.provider_config.vm.newOsPassword
+					
+					orgResource = @machine.provider_config.vm.orgResourceUrl
+					nodeResource = @machine.provider_config.vm.nodeResourceUrl
+					osTemplateResource = @machine.provider_config.vm.osTemplateUrl
+					imageResource = @machine.provider_config.vm.imageResourceUrl
+										
+					begin
+					
+						# Call Rest Client to create a VM
+						response = SecuredCloudRestClient::createVM(sc_connection, orgResource, nodeResource, vmName, vmDescription, vmStorageGB, vmMemoryMB, vmVcpus, vmPowerStatus, imageResource, osTemplateResource, vmOsPassword)
+						
+						#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 Creation 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.creating_vm", :vm_name => @machine.provider_config.vm.name,
+                   :error_message => error_message))
+  							
+  						else
+  						  
+  						  # Put the resource URL of the newly created VM in the environment
+                env[:machine].id = taskStatus.get_result 
+                env[:vm_name] = vmName
+                
+                @logger.debug("VM #{@machine.provider_config.vm.name} has been created with resource URL: #{env[:machine].id}")
+                env[:ui].info(I18n.t("secured_cloud_vagrant.info.success.create_vm", :vm_name => @machine.provider_config.vm.name, 
+                  :resource_url => env[:machine].id))
+                
+  						end
+							
+							 
+						else
+							
+							#Task unsuccessful.
+              @logger.debug("VM Creation 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.creating_vm", :vm_name => @machine.provider_config.vm.name, 
+								:error_message => error_message))
+						end
+						
+					rescue Errno::ETIMEDOUT
+						env[:ui].error(I18n.t("secured_cloud_vagrant.errors.request_timed_out", :request => "create VM '#{vmName}'"))
+          rescue Exception => e
+            env[:ui].error(I18n.t("secured_cloud_vagrant.errors.generic_error", :error_message => e.message))
+					end
+				
+					@app.call(env)
+				end
+				
+			end
+			
+		end
+	end
+end

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

@@ -0,0 +1,105 @@
+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 Delete
+        def initialize(app, env)
+          @app = app
+          @machine = env[:machine]
+          @logger = Log4r::Logger.new('vagrant::secured_cloud::action::delete')
+        end
+
+        def call(env)
+
+          @logger.debug("Deleting VM ...")
+
+          vm_resource_url = @machine.id
+
+          if !vm_resource_url.nil? & !vm_resource_url.empty?
+
+            env[:ui].info(I18n.t("secured_cloud_vagrant.info.destroying"))
+
+            # 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)
+
+            releasePublicIps = (env[:result].nil?) ? true : env[:result]
+
+            @logger.debug("Release public IPs: #{releasePublicIps}")
+
+            begin
+
+              # Send request to delete VM
+              response = SecuredCloudRestClient.deleteVM(sc_connection, vm_resource_url, releasePublicIps)
+
+              # 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 Deletion 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.deleting_vm", :vm_name => env[:vm_name], :error_message => error_message))
+
+                else
+
+                  # Set the resource URL of the delete VM to null in the environment
+                  @logger.debug("VM '#{env[:machine].id}' has been deleted")
+                  env[:ui].info(I18n.t("secured_cloud_vagrant.info.success.delete_vm", :vm_name => env[:vm_name]))
+
+                  env[:machine].id = nil
+                  env[:vm_name] = nil
+
+                end
+
+              else
+
+                #Task unsuccessful.
+                @logger.debug("VM Deletion 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.deleting_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 => "delete VM '#{@machine.provider_config.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 deleted")
+          end
+
+          @app.call(env)
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+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 HasPublicIps
+			
+		  
+				def initialize(app, env)
+					@app = app
+					@machine = env[:machine]
+					@logger = Log4r::Logger.new('vagrant::secured_cloud::action::has_public_ips')
+				end
+
+				def call(env)
+				
+					@logger.debug("Checking whether VM has public IPs ...")
+					
+					vm_resource_url = @machine.id
+					
+					if !vm_resource_url.nil? && !vm_resource_url.empty?
+					
+						begin
+						
+						# Create a Secured Cloud Connection instance to connect to the SecuredCloud API
+            authInfo = @machine.provider_config.auth
+            sc_connection = SecuredCloudConnection.new(authInfo.url, authInfo.applicationKey, authInfo.sharedSecret)
+          
+							# Get the public IPs of the VM
+							publicIps = SecuredCloudRestClient.getVMPublicIPs(sc_connection, vm_resource_url)
+							env[:has_public_ips] = (!publicIps.nil? && !publicIps.empty?)
+							@logger.debug("Has public IPs: #{env[:has_public_ips]}")
+						
+						rescue Errno::ETIMEDOUT
+							env[:ui].error(I18n.t('secured_cloud_vagrant.errors.request_timed_out', :request => "get the public IPs for VM #{env[:vm_name]}"))
+            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