RaaS 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ODQyMTc2NTU0YmJhNTkzZDcwNjRhNzljY2Y5NThhODczMDNiMDQwMw==
+  data.tar.gz: !binary |-
+    NjA3MWJlZmYzNTMzY2EzZjY4NDgyMWMxOTI2ZTM3NjAxOGU1NjA5NQ==
+SHA512:
+  metadata.gz: !binary |-
+    M2Y3ZDQzYmY4YzcwOGIzMTdkZDk0NmJhNjU3YjE0MWYyMmQyNWFjZjc0MGRj
+    NmU0ZDkwM2M5OTNmOTFkZjYyYzg0MThkZWFjOTI3YjhmYjhhZDliOWM1NzYz
+    ZDExMjExOTcwNjZhZTg5ZWUxZmNiNGIxNDBjODg2ZTEyNmM4MDg=
+  data.tar.gz: !binary |-
+    ZmE2NTNhMzI1Y2RjMjk1MWJiYzc1YzFiNmRhNzE2YjZmNjJmYjhlYTE5NGU2
+    YTc1MjcxZTM0ZDRkMjg3ODA0OWY5N2M5ZTliMjZhYzRhODc3YmEyM2Q3NzE4
+    OTY1ZWI5ZjU3MmU3Yjk5OTAwNzg5ZGEyMDBmOTZmMWQ1MzQ3Njg=

data/bin/RaaSCLI

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+require 'RaaSmain'

data/lib/RaaSmain.rb

@@ -0,0 +1,361 @@
+#################################################################################
+####                           Massimo Re Ferre'                             ####
+####                             www.it20.info                               ####
+####  RaaSCLI, a tool that allows you to interact with a DRaaS subscription  ####
+#################################################################################
+
+
+  
+#################################################################################
+####  RaaSmain.rb is the front end program that presents the CLI interface   ####
+####              It leverages the RaaSCore library                          ####
+####    Per best practices I keep the logic separate from the presentation   ####
+#################################################################################
+  
+  
+# These are the additional modules/gems required to run the program 
+
+require 'httparty'
+require 'yaml'
+require 'xml-fu'
+require 'pp'
+require 'awesome_print' #optional - useful for debugging
+
+require 'modules/RaaSCore'
+
+
+# We stole this piece of code (silence_warnings) from the Internet.
+# We am using it to silence the warnings of the certificates settings (below)
+
+def silence_warnings(&block)
+  warn_level = $VERBOSE
+  $VERBOSE = nil
+  result = block.call
+  $VERBOSE = warn_level
+  result
+end
+
+
+# This bypass certification checks...  NOT a great idea for production but ok
+# for test / dev This will be handy for when this script will work with vanilla
+# vCD setups (not just vCHS)
+
+silence_warnings do
+	OpenSSL::SSL::VERIFY_NONE = OpenSSL::SSL::VERIFY_NONE
+end 
+
+# This is what the program accepts as input
+
+def usage
+  puts "\nUsage: #{$PROGRAM_NAME} operation [option1] [option2]\n"
+  puts "\n\toperations: peers|replications|testfailover|testcleanup|failover"
+  puts "\n\te.g. #{$PROGRAM_NAME} peers"
+  puts "\te.g. #{$PROGRAM_NAME} replications ALL"
+  puts "\te.g. #{$PROGRAM_NAME} replications <VM name>"
+  puts "\te.g. #{$PROGRAM_NAME} testfailover <VM name>"
+  puts "\te.g. #{$PROGRAM_NAME} testfailover ALL"
+  puts "\te.g. #{$PROGRAM_NAME} testcleanup <VM name>"
+  puts "\te.g. #{$PROGRAM_NAME} testcleanup ALL"
+  puts "\te.g. #{$PROGRAM_NAME} failover <VM name>"
+  puts "\te.g. #{$PROGRAM_NAME} failover ALL"
+  puts "\n"
+end
+
+
+# These are the variables the program accept as inputs (see the usage section for more info)
+
+$operation = ARGV[0]
+$details = ARGV[1]
+$VM = ARGV[2]
+
+# The if checks if the user called an operation. If not the case, we print the text on how to use the CLI  
+
+if $operation
+
+# Here we instantiate the RaaS class in RaaSCore
+
+  raas = RaaS.new
+  
+  
+# We login (the login method is in RaaSCore)  
+
+  puts "Logging in ...\n\n"
+  raas.login
+
+
+
+# Here we check what operations a user wants the CLI to execute. Every operations calls a particular method 
+# and prints the result returned from the method
+# In general, the way RaaSmain works is that it calls specific methods available in RaaSCore.
+# Some of these methods requires argument(s). Some do not. 
+# Usually these methods returns one or more arrays with information related to the operation being called. 
+# For more detailed info on these methods please refer to RaaSCore.  
+
+  case $operation.chomp
+
+
+# The peers operation calls the peers method and prints the results
+# The method doesn't require an argument and it returns three arrays that includes information re the peers
+ 
+   
+  when 'peers'  
+  	  peerURI, siteName, siteID = raas.peers
+  	  puts "Currently active peer(s):\n".green
+  	  peerURI.length.times do |i|
+  	  						puts "Site Name   : " + siteName[i]
+							puts "Site Id     : " + siteID[i]
+							puts "\n"			
+						   end
+  	  
+  
+  # The replications operation calls the replications method and prints the results.
+  # The replications method requires an argument (the details entered by the user) and returns
+  # a number of arrays whose rows describe the characteristics and status of each active replication 
+    
+  when 'replications'
+    if $details 
+      foundVM, vmname, rpo, replicationState, quiesceGuestEnabled, paused, currentRpoViolation, testRecoveryState, recoveryState, vmhref = raas.replications($details)
+      puts foundVM
+      puts 'Detailed information for currently active replication(s):'.green
+      puts "\n"
+      if foundVM == false 
+      	 puts "Sorry, I could not find the VM(s)".red
+      	 puts "\n"
+      else 
+      vmname.length.times do |i|
+  	  					puts 'VM name               : ' + vmname[i].blue
+         				puts 'RPO                   : ' + rpo[i]
+     					puts 'Replication State     : ' + replicationState[i]
+   	     				puts 'Quiesce Enabled       : ' + quiesceGuestEnabled[i]
+        				puts 'Paused                : ' + paused[i]
+         				puts 'Current RPO Violation : ' + currentRpoViolation[i]
+         				puts 'Test Recovery State   : ' + testRecoveryState[i]
+         				puts 'Recovery State        : ' + recoveryState[i]
+         				puts 'VM URL                : ' + vmhref[i]
+						puts "\n"			
+						end
+      end 
+    else
+      usage
+    end  
+    
+
+
+  # The testfailover operation calls one of the testfailover methods and prints the results.
+  # We check wether the user either wants to testfailover ALL VMs (in which case we call the testfailoverALL method) 
+  # and print results or wants to testfailover one specific VM (in which case we call the testfailoverVM method)
+  # and print results
+    
+  when 'testfailover'
+  	#if the keyword name "ALL is specified we test failover ALL VMs 
+    if $details == "ALL"
+    	print "Are you REALLY SURE you want to test failover ALL the VMs? (yes/no): ".red
+    	puts "\n"
+    	puts "\n"
+		input = STDIN.gets.chomp
+		if input == "yes"
+			puts 'Performing a test failover of all VMs. This may be a long task. Please wait.'.green
+    		puts "\n" 
+      		vmname, testfailover = raas.testfailoverALL
+      	end
+      	# Here we iterarte through the two arrays returned and print the VMs name and whether the testfailover was executed or not
+      	vmname.length.times do |i| 	  	    
+        	if testfailover[i] == false
+        	      puts "Sorry, the VM ".red + vmname[i] + " is not in the proper state to test a failover".red
+       		      puts "\n"
+       		else
+       		      puts "Performing a test failover of VM ".green + vmname[i] + ". Please wait.".green
+       		      puts "\n"
+       	end # if 
+        end #do 
+    else
+         if $details
+         	   # if the details parameter is specified we assume it's a VM name and we run testfailoverVM
+         	   puts 'Performing a test failover of VM '.green + $details + '. Please wait.'.green
+    		   puts "\n" 
+         	   foundVM, testfailover = raas.testfailoverVM($details)
+      		   # Here we check whether the VM name in input actually maps a VM name in the service
+         	   if foundVM == false 
+       				puts "Sorry, I couldn not find the VM ".red + $details
+      				puts "\n"
+     		   else 
+     		   		# If the VM name matches, here we check if the testfailover has actually occurred     
+    			    if testfailover == false
+       					puts "Sorry, the VM ".red + $details + " is not in the proper state to test a failover".red
+       					puts "\n"
+       				end 
+   			   end
+         	else usage 
+         	end       	
+    end
+ 
+
+  # The testcleanup operation calls one of the testcleanup methods and prints the results.
+  # We check wether the user either wants to testcleanup ALL VMs (in which case we call the testcleanupALL method) 
+  # and print results or wants to testcleanup one specific VM (in which case we call the testcleanupVM method)
+  # and print results
+  
+  when 'testcleanup'
+     #if the keyword name "ALL is specified we test cleanup ALL VMs 
+    if $details == "ALL"
+        print "Are you REALLY SURE you want to clean up ALL the VMs? (yes/no): ".red
+        puts "\n"
+    	puts "\n"
+		input = STDIN.gets.chomp
+		if input == "yes"
+			puts 'Performing a test cleanup of all VMs. This may be a long task. Please wait.'.green
+    		puts "\n" 
+    		vmname, testcleanup = raas.testcleanupALL
+    	end
+    	# Here we iterarte through the two arrays returned and print the VMs name and whether the testcleanup was executed or not
+      	vmname.length.times do |i| 	  	    
+        	if testcleanup[i] == false
+        	      puts "Sorry, the VM ".red + vmname[i] + " is not in a test failover state that allows a clean up".red
+       		      puts "\n"
+       		else
+       		      puts "Performing a testcleanup of VM ".green + vmname[i] + ". Please wait.".green
+       		      puts "\n"
+       	 end #if
+       	 end #do
+    else
+         if $details
+               # if the details parameter is specified we assume it's a VM name and we run testcleanupVM
+               puts "Performing a testcleanup of VM ".green + $details + '. Please wait.'.green
+               puts "\n"
+         	   foundVM, testcleanup = raas.testcleanupVM($details)
+         	   # Here we check whether the VM name in input actually maps a VM name in the service
+         	   if foundVM == false 
+   					puts "Sorry, I couldn't not find the VM ".red + $details
+   					puts "\n"
+   			   else
+   			   # If the VM name matches, here we check if the testcleanup has actually occurred     
+   					if testcleanup == false 
+   						puts "Sorry, the VM ".red + $details + " is not in a test failover state that allows a clean up".red
+   						puts "\n"
+			        end
+   		       end
+            else usage 
+            end       	
+    end       		     
+
+
+  # The failover operation calls one of the failover methods and prints the results.
+  # We check wether the user either wants to failover ALL VMs (in which case we call the failoverALL method) 
+  # and print results or wants to failover one specific VM (in which case we call the failoverVM method)
+  # and print results
+
+  when 'failover'
+    #if the keyword name "ALL is specified we failover ALL VMs 
+    if $details == "ALL"
+    	print "Are you REALLY SURE you want to failover ALL the VMs for production usage? (yes/no): ".red
+		input = STDIN.gets.chomp
+		if input == "yes"
+			puts 'Performing a failover of all VMs. This may be a long task. Please wait.'.green
+    		puts "\n"
+         	vmname, failover = raas.failoverALL
+      	end
+      	# Here we iterarte through the two arrays returned and print the VMs name and whether the failover was executed or not
+      	vmname.length.times do |i| 	 
+        	if failover[i] == false
+        	      puts "Sorry, the VM ".red + vmname[i] + " is not in the proper state to failover".red
+       		      puts "\n"
+       		else
+       		      puts "Performing a failover of VM ".green + vmname[i] + ". Please wait.".green
+       		      puts "\n"
+       	 end # if 
+        end #do 
+    else
+         if $details 
+            # if the details parameter is specified we assume it's a VM name and we run failoverVM
+            print "Are you REALLY SURE you want to failover the VM ".red + $details + " for production usage? (yes/no): ".red
+			input = STDIN.gets.chomp
+			if input == "yes"
+         		puts 'Performing the failover of VM '.green + $details + ' for production usage. Please wait.'.green
+    		    puts "\n"
+    		    # Here we check whether the VM name in input actually maps a VM name in the service
+         		foundVM, failover = raas.failoverVM($details)
+         		if foundVM == false 
+  		             puts "Sorry, I couldn't not find the VM ".red + $details
+                     puts "\n"
+                else 
+                   # If the VM name matches, here we check if the failover has actually occurred     
+                   if failover == false
+       		         puts "Sorry, the VM ".red + $details + " is not in the proper state to perform a failover".red
+       		         puts "\n"
+                end 
+    end
+         	end
+             else usage 
+             end
+    end #if    		
+       			
+# If the user specified a wrong operation we suggest how to use the CLI 
+       							       		  
+else #case
+  puts "\n" 
+  puts "Wrong operation!".red
+  usage
+  puts "\n" 
+
+end
+
+# At this stage RaaSmain will have executed an operation per the "case" above" and it logs out
+
+  puts "Logging out ...\n\n"
+  raas.logout
+
+
+# If the user did not specify an operation at all we suggest how to properly use the CLI 
+
+else #if
+  puts "\n" 
+  puts "Missing operation!".red
+  puts "\n" 
+  usage
+
+end #main if
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

data/lib/modules/RaaSCore.rb

@@ -0,0 +1,404 @@
+#################################################################################
+####                           Massimo Re Ferre'                             ####
+####                             www.it20.info                               ####
+####  RaaSCLI, a tool that allows you to interact with a DRaaS subscription  ####
+################################################################################# 
+
+class RaaS
+  include HTTParty
+  format :xml
+    
+#################################################################################
+####        The following functions are standard functions to login          ####
+####                     and logout from the tenant                          ####
+####        They can be used to interact generically with vCloud Air         ####
+#################################################################################
+
+#################################################################################
+####                              IMPORTANT !!                               ####
+####  The program reads a file called RaaSCLI.yml in the working directory   ####
+####        If the file does not exist the program will abort                ####
+####  The file is used to provide the program with connectivity parameters   ####
+#################################################################################
+
+
+# This is the format of the RaaSCLI.yml file:
+# :username: email@domain@OrgName
+# :password: password
+# :site: https://vcd-url
+  
+  
+  def initialize(file_path = 'RaaSCLI.yml')
+    fail "no file #{file_path}" unless File.exists? file_path
+    configuration = YAML.load_file(file_path)
+    self.class.basic_auth configuration[:username], configuration[:password]
+    self.class.base_uri configuration[:site]
+    self.class.default_options[:headers] = { 'Accept' => 'application/*+xml;version=5.6' }
+  end
+
+  def login
+    response = self.class.post('/api/sessions')
+    # setting global cookie var to be used later on
+    @cookie = response.headers['set-cookie']
+    self.class.default_options[:headers] = { 'Accept' => 'application/*+xml;version=5.6', 'Cookie' => @cookie }
+  end
+
+  def logout
+    self.class.delete('/api/session')
+  end
+    
+  def links
+    response = self.class.get('/api/session')
+    response['Session']['Link'].each do |link|
+      puts link['href']
+    end
+  end
+
+
+
+############################################################################
+#####                        RaaSCore starts here                     ######
+############################################################################
+
+ 
+#################################################################################
+####         The following methods are used internally and should          ####
+####                 not be called from outside this module                  ####
+#################################################################################
+ 
+
+  # This internal method queries the vDCs and returns its HREF
+
+  def vDChref
+    response = self.class.get('/api/admin/vdcs/query/')
+    vDC = response['QueryResultRecords']['OrgVdcRecord']
+    vDChref = vDC['href'][46..81]
+    return vDChref
+  end
+  
+  
+  # This internal method retrieves all the active replications in the DR VPC
+  # It returns an array of HREFs for the replications  
+
+  def replicationshref
+    vDC = vDChref
+    response = self.class.get("/api/vdc/#{vDC}/replications")
+    replicationshref = [response['References']['Reference']].flatten
+    return replicationshref
+  end 
+
+
+  # This internal method issues the test failover action against the VM ID passed
+  # It doesn't return anything, it just executes the testfailover
+
+  def testfailover(replicaURI, replicadetailsname)
+  				self.class.default_options[:headers] = {"Accept" => "application/*+xml;version=5.6", "Cookie" => @cookie, "Content-Type" => "application/vnd.vmware.hcs.testFailoverParams+xml"}
+      			testFailoverParam = XmlFu.xml("TestFailoverParams" => { 
+		     	"@xmlns" => "http://www.vmware.com/vr/v6.0",
+		     	"@xmlns:vcloud_v1.5" => "http://www.vmware.com/vcloud/v1.5",
+		     	"@name" => "xs:string",
+		    	"Synchronize" => " false "
+		        })
+      			response = self.class.post("/api/vr/replications/#{replicaURI}/action/testFailover",  :body => testFailoverParam)
+  end 
+
+
+  # This internal method issues the failover action against the VM ID passed
+  # It doesn't return anything, it just executes the failover
+
+  def failover(replicaURI, replicadetailsname)
+    			self.class.default_options[:headers] = {"Accept" => "application/*+xml;version=5.6", "Cookie" => @cookie, "Content-Type" => "application/vnd.vmware.hcs.failoverParams+xml"}
+      			failoverParam = XmlFu.xml("FailoverParams" => { 
+		     	"@xmlns" => "http://www.vmware.com/vr/v6.0",
+		     	"@xmlns:vcloud_v1.5" => "http://www.vmware.com/vcloud/v1.5",
+		     	"@name" => "xs:string",
+		        })
+      			response = self.class.post("/api/vr/replications/#{replicaURI}/action/failover",  :body => failoverParam)
+  end 
+
+
+  # This internal method issues the test cleanup action against the VM ID passed
+  # It doesn't return anything, it just executes the testcleanup
+
+  def testcleanup(replicaURI, replicadetailsname)
+  				response = self.class.post("/api/vr/replications/#{replicaURI}/action/testCleanup")
+  end 
+
+
+
+#################################################################################
+####            The following methods can be used externally.              ####
+####        They implement functions that maps the public API calls          #### 
+#### I'll avoid calling this an SDK for vCloud Air RaaS (but it's an attempt)####             
+#################################################################################
+
+
+  #this method queries the peers associated to the DR VPC and
+  #it returns an array with the peers URIs, an array of site names
+  #and an array of site IDs
+  
+  def peers
+	    vDC = vDChref
+        response = self.class.get("/api/vdc/#{vDC}/peers")
+        peersarray = [response['References']['Reference']].flatten	 
+	  	peerURI = Array.new
+	  	siteName = Array.new
+	  	siteID = Array.new
+	  	i = 0
+		peersarray.each do |peer| 
+					peerhref = peer['href']
+					peerURI[i] = peerhref[51..124]
+					response = self.class.get("/api/vr/peers/#{peerURI[i]}")
+					peerinfo = response['Peer']
+					siteName[i] = peerinfo['SiteName']
+					siteID[i] = peerinfo['SiteUuid']
+					i+= 1
+		end
+		return peerURI, siteName, siteID
+  end 
+
+
+  # This method queries active replications for the DR VPC
+  # It accept a target as an input. It can be "ALL" or an arbitrary name.
+  # If it's an arbitrary name the method will search for a VM with that name
+  # It returns a number of arrays that contains the/all replication/s HREFs 
+  
+  
+  def replications(target)
+    replicationsarray = replicationshref
+    foundVM = false
+	vmname = Array.new
+    rpo = Array.new 
+    replicationState = Array.new
+   	quiesceGuestEnabled = Array.new
+    paused = Array.new
+    currentRpoViolation = Array.new
+    testRecoveryState = Array.new
+    recoveryState = Array.new
+	vmhref = Array.new
+	i = 0
+	if replicationsarray !nil 
+	if target == 'ALL'
+	    replicationsarray.each do |replica|
+	      		replicahref = replica['href']
+	    	    replicaURI = replicahref[58..136]
+ 	     		response = self.class.get("/api/vr/replications/#{replicaURI}")
+ 	     		replicadetails = response['ReplicationGroup']
+ 	     		vmname[i] = replicadetails['name']
+ 	     		rpo[i] = replicadetails['Rpo']
+ 		   		replicationState[i] = replicadetails['ReplicationState']
+ 	  			quiesceGuestEnabled[i] = replicadetails['QuiesceGuestEnabled']
+  		  		paused[i] = replicadetails['Paused']
+    			currentRpoViolation[i] = replicadetails['CurrentRpoViolation']
+    			testRecoveryState[i] = replicadetails['TestRecoveryState']
+    			recoveryState[i] = replicadetails['RecoveryState']
+				vmhref[i] = replicadetails['href']
+				foundVM = true
+				i+= 1
+				end #do
+		else
+				replicationsarray.each do |replica|
+	      				replicahref = replica['href']
+	    	   			replicaURI = replicahref[58..136]
+ 	     				response = self.class.get("/api/vr/replications/#{replicaURI}")
+ 	     				replicadetails = response['ReplicationGroup']
+ 	   			 		if replicadetails['name'] == target
+ 	   			 				 vmname[i] = replicadetails['name']
+ 	     				  		 rpo[i] = replicadetails['Rpo']
+ 						   		 replicationState[i] = replicadetails['ReplicationState']
+ 	  							 quiesceGuestEnabled[i] = replicadetails['QuiesceGuestEnabled']
+  		  						 paused[i] = replicadetails['Paused']
+    							 currentRpoViolation[i] = replicadetails['CurrentRpoViolation']
+    							 testRecoveryState[i] = replicadetails['TestRecoveryState']
+    				 			 recoveryState[i] = replicadetails['RecoveryState']
+								 vmhref[i] = replicadetails['href']
+ 								 foundVM = true
+ 						end #if
+				end #do
+    end #if	replications = ALL 
+    end # if !nil			
+	return foundVM, vmname, rpo, replicationState, quiesceGuestEnabled, paused, currentRpoViolation, testRecoveryState, recoveryState, vmhref
+  end
+
+  
+  # This method issues the testfailover action against the VM name passed as input. 
+  # This method scrolls the array of replications, query the HREFs and search for the VM name
+  # If it finds the VM name, it calls the testfailover method to test failover the VM.
+  # It returns two variables. FoundVM is set to true or false depending if the VM was found or not.
+  # Testfailover is set to true or false depending if the test failover command was issued or not.
+
+  def testfailoverVM(target)
+    replicationsarray = replicationshref
+    testfailover = false
+    foundVM = false
+    replicationsarray.each do |replica|
+      replicahref = replica['href']
+      replicaURI = replicahref[58..136]
+      response = self.class.get("/api/vr/replications/#{replicaURI}")
+      replicadetails = response['ReplicationGroup']
+      if replicadetails['name'] == target
+      		foundVM = true 
+      		if replicadetails['TestRecoveryState'] == 'none'
+     			if replicadetails['RecoveryState'] == 'notStarted'
+      				testfailover = true
+      				testfailover(replicaURI, replicadetails['name'])
+      			end #if
+      		end #if
+      end
+    end
+    return foundVM, testfailover
+  end  
+
+
+  # This method issues the failover action against the VM name passed as input. 
+  # This method scrolls the array of replications, query the HREFs and search for the VM name
+  # If it finds the VM name, it calls the failover method to failover the VM.
+  # It returns two variables. FoundVM is set to true or false depending if the VM was found or not.
+  # Failover is set to true or false depending if the failover command was issued or not.
+    
+  def failoverVM(target)
+    replicationsarray = replicationshref
+    failover = false
+    foundVM = false
+    replicationsarray.each do |replica|
+      replicahref = replica['href']
+      replicaURI = replicahref[58..136]
+      response = self.class.get("/api/vr/replications/#{replicaURI}")
+      replicadetails = response['ReplicationGroup']
+      if replicadetails['name'] == target
+      		foundVM = true 
+      		if replicadetails['TestRecoveryState'] == 'none'
+     			if replicadetails['RecoveryState'] == 'notStarted'
+      				failover = true
+      				failover(replicaURI, replicadetails['name'])
+      			end #if
+      		end #if
+      end #if
+    end #eachdo
+    return foundVM, failover
+  end  
+
+
+  # This method issues the test cleanup action against the VM name passed as input. 
+  # This method scrolls the array of replications, query the HREFs and search for the VM name
+  # If it finds the VM name, it calls the testcleanup function to clean up the test.
+  # It returns two variables. FoundVM is set to true or false depending if the VM was found or not.
+  # Testcleanup is set to true or false depending if the testcleanup command was issued or not.
+
+  def testcleanupVM(target)
+    replicationsarray = replicationshref
+    testcleanup = false
+    foundVM = false
+    replicationsarray.each do |replica|
+      replicahref = replica['href']
+      replicaURI = replicahref[58..136]
+      response = self.class.get("/api/vr/replications/#{replicaURI}")
+      replicadetails = response['ReplicationGroup']
+      if replicadetails['name'] == target 
+                foundVM = true
+  				if replicadetails['TestRecoveryState'] == "complete" or replicadetails['TestRecoveryState'] == "testError" 
+      				testcleanup(replicaURI, replicadetails['name'])
+      				testcleanup = true
+      			else end
+      end #if 
+    end #each do
+    return foundVM, testcleanup
+  end
+ 
+
+  # This method issues the testfailover action against ALL VMs. There is no input. 
+  # This method scrolls the array of replications and calls the testfailover method to test failover all VMs.
+  # It returns two arrays. Vmname contains the name of the VMs.
+  # Testfailover contains true or false depending if the test failover command was issued or not for the VMs.
+  
+ def testfailoverALL
+    replicationsarray = replicationshref
+    vmname = Array.new
+    testfailover = Array.new
+    i = 0
+    replicationsarray.each do |replica|
+      replicahref = replica['href']
+      replicaURI = replicahref[58..136]
+      response = self.class.get("/api/vr/replications/#{replicaURI}")
+      replicadetails = response['ReplicationGroup']
+      vmname[i] = replicadetails['name']
+      if replicadetails['TestRecoveryState'] == 'none'
+      			if replicadetails['RecoveryState'] == 'notStarted'
+      				testfailover[i] = true
+      				testfailover(replicaURI, replicadetails['name'])
+      			else testfailover[i] = false 
+      			end 
+      else testfailover[i] = false 
+      end #if    	
+      i+= 1
+    end #each do
+    return vmname, testfailover
+  end  
+  
+
+  # This method issues the testcleanup action against ALL VMs. There is no input. 
+  # This method scrolls the array of replications and calls the testcleanup method to testcleanup all VMs.
+  # It returns two arrays. Vmname contains the name of the VMs.
+  # Testcleanup contains true or false depending if the testcleanup command was issued or not for the VMs.  
+  
+  def testcleanupALL 
+    replicationsarray = replicationshref
+    vmname = Array.new
+    testcleanup = Array.new
+    i = 0
+    replicationsarray.each do |replica|
+      replicahref = replica['href']
+      replicaURI = replicahref[58..136]
+      response = self.class.get("/api/vr/replications/#{replicaURI}")
+      replicadetails = response['ReplicationGroup']
+      vmname[i] = replicadetails['name']
+      if replicadetails['TestRecoveryState'] == "complete"  or replicadetails['TestRecoveryState'] == "testError"
+      				testcleanup[i] = true
+      				testcleanup(replicaURI, replicadetails['name'])
+      			else testcleanup[i] = false 
+      end #if
+      i+= 1
+    end #each do   
+    return vmname, testcleanup 
+  end
+  
+  
+  # This method issues the failover action against ALL VMs. There is no input. 
+  # This method scrolls the array of replications and calls the failover method to failover all VMs.
+  # It returns two arrays. Vmname contains the name of the VMs.
+  # Failover contains true or false depending if the failover command was issued or not for the VMs.
+  
+  def failoverALL
+    replicationsarray = replicationshref
+    vmname = Array.new
+    failover = Array.new
+    i = 0
+    replicationsarray.each do |replica|
+      replicahref = replica['href']
+      replicaURI = replicahref[58..136]
+      response = self.class.get("/api/vr/replications/#{replicaURI}")
+      replicadetails = response['ReplicationGroup']
+      vmname[i] = replicadetails['name']
+      if replicadetails['TestRecoveryState'] == 'none'
+      			if replicadetails['RecoveryState'] == 'notStarted'
+      				failover[i] = true
+      				failover(replicaURI, replicadetails['name'])
+      			else failover[i] = false 
+      			end
+      else failover[i] = false 
+      end #if
+      i+= 1
+    end #each do
+    return vmname, failover
+  end  
+  
+  
+  
+end # class RaaS
+
+
+
+
+
+
+

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: RaaS
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Massimo Re Ferrè
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+- !ruby/object:Gem::Dependency
+  name: xml-fu
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+description: A set of tools that allows VMware vCloud Air customers to interact programmatically
+  with RaaS - Recovery as a Service
+email: massimo@it20.info
+executables:
+- RaaSCLI
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/RaaSmain.rb
+- lib/modules/RaaSCore.rb
+- bin/RaaSCLI
+homepage: http://it20.info
+licenses:
+- GPL
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.11
+signing_key: 
+specification_version: 4
+summary: VMware vCloud Air RaaS program
+test_files: []