vagrant-node 0.0.2

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in vagrant-node.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,14 @@
+Copyright (C) Cátedra SAES-UMU 2013 <fjsanpedro@gmail.com>
+ 
+VAGRANT-NODE is free software: you can redistribute it and/or modify it
+under the terms of the GNU Lesser General Public License as published
+by the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+VAGRANT-NODE is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+See the GNU Lesser General Public License for more details.
+ 
+You should have received a copy of the GNU Lesser General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.

data/README.md

@@ -0,0 +1,4 @@
+vagrant-node
+============
+
+Vagrant-node plugin for Vagrant Framework

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/lib/vagrant-node.rb

@@ -0,0 +1,21 @@
+require "vagrant-node/version"
+
+module Vagrant
+  module Node
+    class Plugin < Vagrant.plugin("2")
+    
+    	name "node"
+    	description <<-DESC
+    	ESTE PLUGIN ES EL QUE LANZA EL SERVIDOR
+    	DESC
+    	
+		
+			command ('nodeserver') do
+					require_relative "vagrant-node/nodeservercommand"
+					Command
+			end
+		
+		
+    end
+  end
+end

data/lib/vagrant-node/actions/snapshot.rb

@@ -0,0 +1,285 @@
+require 'pp'
+require "rexml/document"
+#require 'rubygems'
+require 'zip/zip'
+
+
+module Vagrant
+  module Node
+  	
+  	class SnapshotAction
+  		LIST = :list
+  		TAKE = :take
+  		RESTORE = :restore
+  		BACKUP = :backup
+  		ERROR = :error
+  		
+			def initialize(app, env)
+				@app = app
+			end
+		
+			def call(env)
+				
+				#FIXME generate a result code error to this case in order 
+				#to provide more info to the client
+				return @app.call(env) if env[:machine].state.id==:not_created
+				
+				current_driver=env[:machine].provider.driver
+				
+				begin				
+					current_driver.check_snapshot_stuff
+				rescue Exception => e
+					case env[:machine].provider_name.to_s					
+						when "virtualbox" then							
+							attach_vbox_methods(current_driver)
+					end
+					
+				end
+				
+				case env[:machine_action]
+					when LIST then
+						env[:snapshots_list]=current_driver.list
+					when TAKE then
+						env[:last_snapshot]=current_driver.take_snapshot(env[:snapshot_name],env[:snapshot_desc])
+					when RESTORE then
+						
+						env[:restore_result]=current_driver.restore_snapshot(env[:snapshot_id])
+					when BACKUP then
+						env[:bak_filename]=current_driver.backup_vm(env[:machine].name.to_s,env[:machine].data_dir)
+				end
+				
+				@app.call(env)
+				
+			end
+			
+			private
+			
+			def attach_vbox_methods(driver)
+				
+				def driver.check_snapshot_stuff
+						return true
+				end					
+					
+				#FIXME Si no se hace con --pause y la máquina esta running
+				#se produce un error y deja a la máquina en estado 'gurumeditating'
+				def driver.take_snapshot(name,description=" ")						
+						
+					begin
+						#Execute the take command
+						if (description)
+							execute("snapshot",self.uuid,"take",name,"--description",description,"--pause")
+						else
+							execute("snapshot",self.uuid,"take",name,"--pause")
+						end
+
+						snapshot = {}						
+						#Getting the uuid of the latest snapshot
+						execute("snapshot",self.uuid,"list").split("\n").each do |line|
+						
+							if line =~ /Name:\s(.*?)\s\(UUID:\s(.*?)\)\s\*$/						
+								snapshot[:name] = $1
+								snapshot[:id] = $2
+							end
+						
+						end
+						
+						#return snapshot
+						snapshot					
+						
+						
+					rescue => e
+						puts e.message
+						return nil
+					end
+						
+						
+				end #driver.take_snapshot
+			
+				
+				def driver.backup_vm(vmname,path)						
+					
+					zipfilename=nil
+					begin
+						#Execute the export command
+						
+						
+						time = Time.now						
+						basename = "Backup.#{vmname}.#{time.year}.#{time.month}.#{time.day}.#{time.hour}.#{time.min}.#{time.sec}"
+						zipfilename = path.to_s + '/'+ basename + '.zip'
+						
+						vmdir = nil
+						execute("showvminfo",self.uuid,"--machinereadable").split("\n").each do |line|
+							vmdir = File.dirname($1) if line =~ /^CfgFile="(.*?)"$/													 
+						end
+
+						
+						Zip::ZipFile.open(zipfilename, Zip::ZipFile::CREATE) do |zipfile|
+								Dir[File.join(vmdir, '**', '**')].each do |file|									
+									zipfile.add(file.sub(vmdir+"/", ''), file)
+								end
+						end
+							
+						zipfilename					
+						
+					rescue => e						
+						File.delete(zipfilename) if File.exists?(zipfilename)
+						return ERROR
+					end
+						
+						
+				end #driver.backup_vm
+				
+				
+				
+#				def driver.export_vm(path)						
+#					
+#					begin
+						#Execute the export command
+#						basename = "Backup.#{Time.now.to_i.to_s}"
+#						filename = path + basename
+#						execute("export",self.uuid,"--output",filename.to_s+".ovf")
+#						zipfilename = filename.to_s + '.zip'
+#						
+#						files_to_zip = []
+#						Dir.chdir(path)
+#						Dir.glob(basename+"*") do |file|
+#							files_to_zip << file
+#						end
+#						
+#						Zip::ZipFile.open(zipfilename, Zip::ZipFile::CREATE) do |zipfile|
+#							files_to_zip.each do |file|
+#								zipfile.add(file,file)
+#							end
+#						end
+#												
+#						
+#						Cleaning files						
+#						files_to_zip.each do |file|
+#							File.delete(file)								
+#						end
+#						return zipfilename					
+#						
+#					rescue => e
+#						puts e.message
+#						return ERROR
+#					end
+						
+						
+				#end #driver.export_vm
+				
+				
+				def driver.list
+					config = nil
+					current_snapshot = nil
+					
+					execute("showvminfo",self.uuid,"--machinereadable").split("\n").each do |line|
+						config = $1 if line =~ /^CfgFile="(.*?)"$/
+													
+					end						
+					
+					snapshots = []				
+					
+					doc = REXML::Document.new File.new(config)
+					machine = doc.elements["VirtualBox/Machine"]
+					
+					@current_snapshot = machine.attributes["currentSnapshot"]
+					
+					snapshots = search_snapshot(machine) if @current_snapshot
+					
+					
+					snapshots						
+					
+						
+				end #driver.list
+				
+				def driver.search_snapshot(path)
+					
+					snapshots = []
+					if path					
+						path.elements.each("Snapshot") { |element|
+							snapshot = {}
+							
+							snapshot[:uuid] = element.attributes["uuid"]							
+							snapshot[:name] = element.attributes["name"]							
+							snapshot[:timestamp] = element.attributes["timeStamp"]
+							
+							if 	element.elements["Description"]						
+								snapshot[:description] =	element.elements["Description"].text
+							else 
+								snapshot[:description] =	" "
+							end
+							
+							if (snapshot[:uuid]==@current_snapshot)
+																					
+								snapshot[:current_state] = true
+							else
+								snapshot[:current_state] = false
+							end
+							
+							snapshot[:snapshots] = search_snapshot(element.elements["Snapshots"])
+							
+							snapshots << snapshot						
+						}
+					end #driver.search_snapshot(path)
+					
+					#return snapshot array
+					snapshots
+					
+				end
+
+				#snapipd could be the snapshot uuid or its name
+				def driver.restore_snapshot(snapid)						
+						
+					snapshots = []
+					
+					begin
+													
+						result = execute("snapshot",self.uuid,"restore",snapid)
+						
+						if result =~ /^Restoring snapshot\s(.*?)$/
+								snapshots << $1									
+						end
+						
+						#return snapshot array						
+						snapshots
+						
+					rescue Vagrant::Errors::VBoxManageError => e
+							return snapshots if e.message=~ /Could not find a snapshot named/						
+					end						
+				end
+								
+			end # attach_vbox_methods(driver)		
+			 
+			
+  	end
+  	
+  end
+end
+
+#				def driver.list
+#						puts "LISTING SNAPSHOT"
+#						begin
+#						snapshots = []
+#						puts "UUID #{self.uuid}"
+#						execute("snapshot",self.uuid,"list").split("\n").each do |line|
+#							snapshot = {}							
+#
+#							if line =~ /Name:\s(.*?)\s\(UUID:\s(.*?)\)$/								
+#								snapshot[:name] = $1
+#								snapshot[:id] = $2
+#								snapshot[:current_state] = false						 	
+#						 	elsif line =~ /Name:\s(.*?)\s\(UUID:\s(.*?)\)\s\*$/						
+#								snapshot[:name] = $1
+#								snapshot[:id] = $2
+#								snapshot[:current_state] = true
+#						 	end					
+#						 	snapshots.push(snapshot)		
+#						end
+#						rescue Exception => e
+#							puts e.message
+#						end
+#						
+#						puts snapshots
+#						return snapshots
+#				end
+				

data/lib/vagrant-node/api.rb

@@ -0,0 +1,160 @@
+require 'rubygems'
+require 'sinatra'
+require 'json'
+require 'rack'
+require 'vagrant-node/clientcontroller'
+require 'vagrant-node/apidesc'
+
+
+require 'pp'
+module Vagrant
+	module Node
+		module ServerAPI
+			
+			class API < Sinatra::Base
+				include RestRoutes 
+				before do 
+  					content_type :json
+				end
+				
+				
+				#UPLOAD A FILE
+#				post '/' do
+				#  tempfile = params['file'][:tempfile]
+				#  filename = params['file'][:filename]
+				#  File.copy(tempfile.path, "./files/#{filename}")
+				#  redirect '/'
+				#end		
+				
+				
+#				before '/admin/*' do
+#  				authenticate!
+#				end
+				
+			######### FIXME DELETE #####################			
+			get '/' do
+					"Hello World"
+			end		
+			
+			###############################################
+				
+			get RouteManager.box_list_route	do				
+				ClientController.listboxes.to_json
+			end
+
+			delete RouteManager.box_delete_route do					
+				handle_response_result(ClientController.box_delete(params[:box],params[:provider]))
+			end				
+			
+			post RouteManager.box_add_route do					
+				handle_response_result(ClientController.box_add(params[:box],params[:url]))
+			end
+			
+				
+								
+			get RouteManager.vm_status_all_route do
+				handle_response_result(ClientController.vm_status(nil))
+			end
+			
+				
+
+			get RouteManager.vm_status_route do
+				handle_response_result(ClientController.vm_status(params[:vm]))
+			end
+			
+			#accept :vmname as paramter. This parameter
+			#could be empty
+			post RouteManager.vm_up_route do
+				handle_response_result(ClientController.vm_up(params[:vmname]))
+			end
+				
+			#accept :vmname and :force as paramters
+			post RouteManager.vm_halt_route do
+				handle_response_result(ClientController.vm_halt(params[:vmname],params[:force]))
+			end
+				
+			#accept :vmname as paramter. This parameter
+			#could be empty
+			post RouteManager.vm_destroy_route do
+				handle_response_result(ClientController.vm_confirmed_destroy(params[:vmname]))
+			end
+				
+			#accept :vmname as paramter. This parameter
+			#could be empty
+			post RouteManager.vm_suspend_route do
+				handle_response_result(ClientController.vm_suspend(params[:vmname]))
+			end
+				
+			#accept :vmname as paramter. This parameter
+			#could be empty
+			post RouteManager.vm_resume_route do					
+				handle_response_result(ClientController.vm_resume(params[:vmname]))
+			end
+			
+			post RouteManager.vm_provision_route do
+				handle_response_result(ClientController.vm_provision(params[:vmname]))
+			end
+				
+				
+				
+			get RouteManager.vm_sshconfig_route do				
+				handle_response_result(ClientController.vm_ssh_config(params[:vm]))
+			end
+				
+			get RouteManager.snapshots_all_route do
+				handle_response_result(ClientController.vm_snapshots(nil))
+			end
+			
+					
+			
+			get RouteManager.vm_snapshots_route do
+				handle_response_result(ClientController.vm_snapshots(params[:vm]))
+			end
+			
+			get RouteManager.vm_snapshot_take_route do														
+				result=ClientController.vm_snapshot_take_file(params[:vmname])
+				
+					
+				send_file "#{result[1]}", :filename => result[1], 
+									:type => 'Application/octet-stream' if result[0]==200 && params[:download]="true"
+				
+				status result[0]
+					
+			end
+			
+						
+			post RouteManager.vm_snapshot_take_route do
+					handle_response_result(ClientController.vm_snapshot_take(params[:vmname],params[:name],params[:desc]))
+			end
+			
+			
+			post RouteManager.vm_snapshot_restore_route do
+					handle_response_result(ClientController.vm_snapshot_restore(params[:vmname],params[:snapid]))
+			end
+			
+			
+			get RouteManager.vm_backup_log_route do
+				handle_response_result(ClientController.backup_log(params[:vm]))
+			end
+			
+				
+
+			get RouteManager.node_backup_log_route do
+				handle_response_result(ClientController.backup_log(nil))
+			end
+			
+				
+			private
+			def handle_response_result(result)														
+					if (!result)											
+						status 500
+					elsif (result.empty?)												
+						status 404
+					end					
+					result.to_json
+			end
+				
+			end
+		end
+	end
+end