vagrant-ganeti 0.0.1

data/lib/vagrant-plugin-ganeti/action/sync_folders.rb

@@ -0,0 +1,85 @@
+require "log4r"
+
+require "vagrant/util/subprocess"
+
+require "vagrant/util/scoped_hash_override"
+
+require "vagrant/util/which"
+
+module VagrantPlugins
+  module GANETI
+    module Action
+      # This middleware uses `rsync` to sync the folders over to the
+      # Ganeti instance.
+      class SyncFolders
+        include Vagrant::Util::ScopedHashOverride
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_ganeti::action::sync_folders")
+        end
+
+        def call(env)
+          @app.call(env)
+
+          ssh_info = env[:machine].ssh_info
+
+          env[:machine].config.vm.synced_folders.each do |id, data|
+            data = scoped_hash_override(data, :ganeti)
+
+            # Ignore disabled shared folders
+            next if data[:disabled]
+
+            unless Vagrant::Util::Which.which('rsync')
+              env[:ui].warn(I18n.t('vagrant_ganeti.rsync_not_found_warning'))
+              break
+            end
+
+            hostpath  = File.expand_path(data[:hostpath], env[:root_path])
+            guestpath = data[:guestpath]
+
+            # Make sure there is a trailing slash on the host path to
+            # avoid creating an additional directory with rsync
+            hostpath = "#{hostpath}/" if hostpath !~ /\/$/
+
+            # on windows rsync.exe requires cygdrive-style paths
+            if Vagrant::Util::Platform.windows?
+              hostpath = hostpath.gsub(/^(\w):/) { "/cygdrive/#{$1}" }
+            end
+
+            env[:ui].info(I18n.t("vagrant_ganeti.rsync_folder",
+                                :hostpath => hostpath,
+                                :guestpath => guestpath))
+
+            # Create the guest path
+            env[:machine].communicate.sudo("mkdir -p '#{guestpath}'")
+            env[:machine].communicate.sudo(
+              "chown #{ssh_info[:username]} '#{guestpath}'")
+
+            # Rsync over to the guest path using the SSH info
+            command = [
+              "rsync", "--verbose", "--archive", "-z",
+              "--exclude", ".vagrant/",
+              "-e", "ssh -p #{ssh_info[:port]} -o StrictHostKeyChecking=no -i '#{ssh_info[:private_key_path]}'",
+              hostpath,
+              "#{ssh_info[:username]}@#{ssh_info[:host]}:#{guestpath}"]
+
+            # we need to fix permissions when using rsync.exe on windows, see
+            # http://stackoverflow.com/questions/5798807/rsync-permission-denied-created-directories-have-no-permissions
+            if Vagrant::Util::Platform.windows?
+              command.insert(1, "--chmod", "ugo=rwX")
+            end
+
+            r = Vagrant::Util::Subprocess.execute(*command)
+            if r.exit_code != 0
+              raise Errors::RsyncError,
+                :guestpath => guestpath,
+                :hostpath => hostpath,
+                :stderr => r.stderr
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-plugin-ganeti/action/timed_provision.rb

@@ -0,0 +1,22 @@
+require "vagrant-ganeti/util/timer"
+
+module VagrantPlugins
+  module GANETI
+    module Action
+      # This is the same as the builtin provision except it times the
+      # provisioner runs.
+      class TimedProvision < Vagrant::Action::Builtin::Provision
+        def run_provisioner(env, name, p)
+          timer = Util::Timer.time do
+            super
+          end
+
+          env[:metrics] ||= {}
+          env[:metrics]["provisioner_times"] ||= []
+          env[:metrics]["provisioner_times"] << [name, timer]
+	  puts "Done Timed"
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-plugin-ganeti/action/unlink_server.rb

@@ -0,0 +1,30 @@
+require "log4r"
+
+module VagrantPlugins
+  module GANETI
+    module Action
+      # "unlink" vagrant and the managed server
+      class UnlinkServer
+
+        def initialize(app, env)
+          @app    = app
+          @logger = Log4r::Logger.new("vagrant_ganeti::action::unlink_server")
+        end
+
+        def call(env)
+
+          server = env[:machine].id
+
+          # "Unlink" 
+          env[:ui].info(I18n.t("vagrant_ganeti.unlinking_server", :host => server))
+          env[:ui].info(" -- Server: #{server}")
+
+          # set machine id to nil
+          env[:machine].id = nil
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-plugin-ganeti/action/warn_networks.rb

@@ -0,0 +1,19 @@
+module VagrantPlugins
+  module GANETI
+    module Action
+      class WarnNetworks
+        def initialize(app, env)
+          @app = app
+        end
+
+        def call(env)
+          if env[:machine].config.vm.networks.length > 0
+            env[:ui].warn(I18n.t("vagrant_ganeti.warn_networks"))
+          end
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-plugin-ganeti/action.rb

@@ -0,0 +1,137 @@
+require "pathname"
+
+require "vagrant/action/builder"
+
+module VagrantPlugins
+  module GANETI
+    module Action
+      # Include the built-in modules so we can use them as top-level things.
+      include Vagrant::Action::Builtin
+      
+      # This action is called to establish linkage between vagrant and the Ganeti
+      def self.action_up
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use HandleBoxUrl
+          b.use ConfigValidate
+          b.use WarnNetworks
+	  b.use ConnectGANETI
+	  b.use RunInstance
+          #b.use LinkServer
+=begin
+b.use HandleBoxUrl
+b.use ConfigValidate
+b.use Call, IsReachable do |env, b2|
+if env[:result]
+b2.use !MessageNotReachable
+next
+end
+
+b2.use Provision
+b2.use SyncFolders
+b2.use WarnNetworks
+b2.use LinkServer
+end
+=end
+        end
+      end
+
+
+    def self.action_destroy
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use Call, DestroyConfirm do |env, b2|
+            if env[:result]
+              b2.use ConfigValidate
+              b2.use ConnectGANETI
+              b2.use RemoveInstance
+            else
+              b2.use MessageWillNotDestroy
+            end
+          end
+        end
+      end
+
+      # This action is called when `vagrant provision` is called.
+      def self.action_provision
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use WarnNetworks
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              b2.use MessageNotReachable
+              next
+            end
+
+            b2.use Provision
+            b2.use SyncFolders
+          end
+        end
+      end
+
+      # This action is called to read the state of the machine. The
+      # resulting state is expected to be put into the `:machine_state_id`
+      # key.
+      def self.action_read_state
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use ReadState
+        end
+      end
+
+      # This action is called to SSH into the machine.
+      def self.action_ssh
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use WarnNetworks
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              b2.use MessageNotReachable
+              next
+            end
+
+            b2.use SSHExec
+          end
+        end
+      end
+
+      # This action is called to read the SSH info of the machine. The
+      # resulting state is expected to be put into the `:machine_ssh_info`
+      # key.
+      def self.action_read_ssh_info
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+        #  b.use ConnectGANETI
+          b.use ReadSSHInfo
+        end
+      end
+
+      def self.action_ssh_run
+        Vagrant::Action::Builder.new.tap do |b|
+          b.use ConfigValidate
+          b.use WarnNetworks
+          b.use Call, IsCreated do |env, b2|
+            if !env[:result]
+              b2.use MessageNotReachable
+              next
+            end
+
+            b2.use SSHRun
+          end
+        end
+      end
+
+
+      # The autoload farm
+      action_root = Pathname.new(File.expand_path("../action", __FILE__))
+      autoload :ConnectGANETI, action_root.join("connect_ganeti")
+      autoload :IsReachable, action_root.join("is_reachable")
+      autoload :IsCreated, action_root.join("is_created")
+      autoload :MessageNotReachable, action_root.join("message_not_reachable")
+      autoload :ReadState, action_root.join("read_state")
+      autoload :ReadSSHInfo, action_root.join("read_ssh_info")
+      autoload :SyncFolders, action_root.join("sync_folders")
+      autoload :WarnNetworks, action_root.join("warn_networks")
+      autoload :RunInstance, action_root.join("run_instance")
+      autoload :RemoveInstance, action_root.join("remove_instance")
+    end
+  end
+end

data/lib/vagrant-plugin-ganeti/config.rb

@@ -0,0 +1,308 @@
+require "vagrant"
+
+module VagrantPlugins
+  module GANETI
+    class Config < Vagrant.plugin("2", :config)
+      # The username for accessing GANETI.
+      #
+      # @return [String]
+      attr_accessor :rapi_user
+
+      # The password for accessing GANETI.
+      #
+      # @return [String]
+      attr_accessor :rapi_pass
+
+      # The Host Detail
+      #
+      # @return [String]
+      attr_accessor :cluster
+
+      # The timeout to wait for an instance to become ready.
+      #
+      # @return [Fixnum]
+      attr_accessor :instance_ready_timeout
+
+     
+      # The version of the GANETI api to use
+      #
+      # @return [String]
+      attr_accessor :version
+
+
+      # The name of the OS to use.
+      #
+      # @return [String]
+      attr_accessor :os_type
+
+      # The name of the OS to use.
+      #
+      # @return [String]
+      attr_accessor :disk_template
+
+      # An array of hash of disk sizes
+      #
+      # @return [{hash }]
+      attr_accessor :disks
+
+      # The name of the Instance
+      #
+      # @return [String]
+      attr_accessor :instance_name
+
+      # Mode of Creation
+      #
+      # @return [String]
+      attr_accessor :mode
+
+      # Network Configurations
+      #
+      # @return [{hash}]
+      attr_accessor :nics
+
+      # The name of the Primary Node
+      #
+      # @return [String]
+      attr_accessor :pnode
+
+      # The name of the Secondary Node for DRBD template
+      #
+      # @return [String]
+      attr_accessor :snode
+      
+      # The name of the Iallocatoy
+      #
+      # @return [String]
+      attr_accessor :iallocator
+
+      # Memory Configurations in MB's
+      #
+      # @return [String]
+      attr_accessor :memory
+
+      # VCPU configuration
+      #
+      # @return [String]
+      attr_accessor :vcpus
+
+      # Name Check
+      #
+      # @return [Boolean]
+      attr_accessor :name_check
+
+      # IP Check  configuration
+      #
+      # @return [Boolean]
+      attr_accessor :ip_check
+
+      # hvparam Configs
+      #
+      # @return [String]
+      attr_accessor :hvparam
+      
+      # hvparam Configs
+      #
+      # @return [String]
+      attr_accessor :boot_order
+      
+      # hvparam Configs 
+      #
+      # @return [String]
+      attr_accessor :cdrom_image_path
+
+      # hvparam Configs 
+      #
+      # @return [String]
+      attr_accessor :nic_type
+      
+      # hvparam Configs 
+      #
+      # @return [String]
+      attr_accessor :disk_type
+
+      # hvparam Configs 
+      #
+      # @return [String]
+      attr_accessor :cpu_type
+      
+      # hvparam Configs 
+      #
+      # @return [String]
+      attr_accessor :kernel_path
+
+      # hvparam Configs 
+      #
+      # @return [String]
+      attr_accessor :kernel_args
+      
+      # hvparam Configs 
+      #
+      # @return [String]
+      attr_accessor :initrd_path
+
+      # hvparam Configs 
+      #
+      # @return [String]
+      attr_accessor :root_path
+
+      # hvparam Configs 
+      #
+      # @return [String]
+      attr_accessor :serial_console
+
+      # hvparam Configs 
+      #
+      # @return [String]
+      attr_accessor :kvm_flag
+      
+      def initialize()
+        @rapi_user    	= UNSET_VALUE
+        @rapi_pass 	= UNSET_VALUE
+	@cluster        = UNSET_VALUE
+        @version     	= 2
+        @os_type      	= UNSET_VALUE
+	@disk_template 	= UNSET_VALUE
+	@disks 		= UNSET_VALUE
+	@instance_name 	= UNSET_VALUE
+	@mode		= UNSET_VALUE
+	@nics 		= UNSET_VALUE
+	@pnode 		= UNSET_VALUE
+	@snode 		= UNSET_VALUE
+	@iallocator 	= UNSET_VALUE
+	@memory 	= UNSET_VALUE
+	@vcpus 		= UNSET_VALUE
+	@ip_check 	= UNSET_VALUE
+	@name_check 	= UNSET_VALUE
+	@boot_order 	= UNSET_VALUE
+	@cdrom_image_path = UNSET_VALUE
+	@nic_type	= UNSET_VALUE
+	@disk_type	= UNSET_VALUE
+	@cpu_type	= UNSET_VALUE
+	@kernel_path 	= UNSET_VALUE
+	@kernel_args 	= UNSET_VALUE
+	@initrd_path	= UNSET_VALUE
+	@root_path	= UNSET_VALUE
+	@serial_console	= UNSET_VALUE
+	@kvm_flag 	= UNSET_VALUE
+        @__finalized 	= false
+      end
+
+      def finalize!
+        # Username and password for the Ganei RAPI must be set .
+        @rapi_user     = nil if @rapi_user   == UNSET_VALUE
+        @rapi_pass = nil  if @rapi_pass == UNSET_VALUE
+
+        # host must be nil, since we can't default that
+        @cluster = nil if @cluster == UNSET_VALUE
+
+        # OS_NAME must be nil, since we can't default that
+        @os_type = nil if @os_type == UNSET_VALUE
+
+        # disk_template since we can't default that
+        @disk_template = "plain" if @disk_template == UNSET_VALUE
+
+        # disks must be nil, since we can't default that
+        @disks = [{"size"=>"8000"}]  if @disks == UNSET_VALUE
+
+        # instance_name must be nil, since we can't default that
+        @instance_name = nil if @instance_name == UNSET_VALUE
+
+        # mode must be nil, since we can't default that
+        @mode = "create" if @mode == UNSET_VALUE
+
+        # nics must be nil, since we can't default that
+        @nics = nil if @nics == UNSET_VALUE
+
+        # pnode must be nil, since we can't default that
+        @pnode = nil if @pnode == UNSET_VALUE
+        
+	# snode must be nil, since we can't default that
+        @snode = nil if @snode == UNSET_VALUE
+
+        # iallocator Get default from ganeti cluster
+        @iallocator = "__DEFAULT__" if @iallocator == UNSET_VALUE
+
+        # memory must be nil, since we can't default that
+        @memory = nil if @memory == UNSET_VALUE
+
+        # vcpu must be nil, since we can't default that
+        @vcpus = nil if @vcpus == UNSET_VALUE
+	
+        # ip_check defaults to True
+        @ip_check = true if @ip_check == UNSET_VALUE
+
+        # name_check defaults to True
+        @name_check = true if @name_check == UNSET_VALUE
+	
+        # boot_order defaults to Nil
+        @boot_order = nil if @boot_order == UNSET_VALUE
+	
+        # cdrom_image_path to Nil
+        @cdrom_image_path= nil if @cdrom_image_path == UNSET_VALUE
+	
+        # nic_type defaults to nil
+        @nic_type = nil if @nic_type == UNSET_VALUE
+	
+        # disk_type defaults to nil
+        @disk_type = nil if @disk_type == UNSET_VALUE
+	
+        # cpu_type defaults to nil
+        @cpu_type = nil if @cpu_type == UNSET_VALUE
+		
+        # kernel_path defaults to nil
+        @kernel_path = nil if @kernel_path == UNSET_VALUE
+        
+	# kernel_args defaults to nil
+        @kernel_args = nil if @kernel_args == UNSET_VALUE
+        
+        
+	# initrd_path defaults to nil
+        @initrd_path = nil if @initrd_path == UNSET_VALUE
+	
+	# root_path_path defaults to nil
+        @root_path = nil if @root_path == UNSET_VALUE
+	
+	# serial_console defaults to nil
+        @serial_console = nil if @serial_console == UNSET_VALUE
+
+	# kvm_flag defaults to nil
+        @kvm_flag = nil if @kvm_flag == UNSET_VALUE
+	
+	# Set the default timeout for waiting for an instance to be ready
+        @instance_ready_timeout = 120 if @instance_ready_timeout == UNSET_VALUE
+
+        @version = nil if @version == UNSET_VALUE
+
+        
+        # Mark that we finalized
+        @__finalized = true
+      end
+
+
+      def validate(machine)
+        errors = _detected_errors
+
+        errors << I18n.t("vagrant_ganeti.config.username_required") if @rapi_user.nil?
+        errors << I18n.t("vagrant_ganeti.config.password_required") if @rapi_pass.nil?
+	errors << I18n.t("vagrant_ganeti.config.host_required") if @cluster.nil?
+	errors << I18n.t("vagrant_ganeti.config.os_name_required") if @os_type.nil?
+	errors << I18n.t("vagrant_ganeti.config.disk_template_required") if @disk_template.nil?
+        errors << I18n.t("vagrant_ganeti.config.disks_required") if @disks == nil
+	errors << I18n.t("vagrant_ganeti.config.instance_name_required") if @instance_name.nil?
+        errors << I18n.t("vagrant_ganeti.config.mode_required") if @mode.nil?
+	errors << I18n.t("vagrant_ganeti.config.nics_required") if @nics.nil?
+	errors << I18n.t("vagrant_ganeti.config.pnode_required") if @pnode.nil? and  @iallocator.nil?
+	errors << I18n.t("vagrant_ganeti.config.snode_required") if @snode.nil? and  @disk_template == "drbd" and @iallocator.nil?
+   	{ "GANETI Provider" => errors }
+
+      end
+      def get_config()
+        if !@__finalized
+          raise "Configuration must be finalized before calling this method."
+        end
+
+        self
+      end
+    end
+  end
+end

data/lib/vagrant-plugin-ganeti/errors.rb

@@ -0,0 +1,19 @@
+require "vagrant"
+
+module VagrantPlugins
+  module GANETI
+    module Errors
+      class VagrantGANETIError < Vagrant::Errors::VagrantError
+        error_namespace("vagrant_ganeti.errors")
+      end
+
+      class InstanceReadyTimeout < VagrantGANETIError
+        error_key(:instance_ready_timeout)
+      end
+
+      class RsyncError < VagrantGANETIError
+        error_key(:rsync_error)
+      end
+    end
+  end
+end

data/lib/vagrant-plugin-ganeti/plugin.rb

@@ -0,0 +1,73 @@
+begin
+  require "vagrant"
+rescue LoadError
+  raise "The Vagrant GANETI plugin must be run within Vagrant."
+end
+
+# This is a sanity check to make sure no one is attempting to install
+# this into an early Vagrant version.
+if Vagrant::VERSION < "1.2.0"
+  raise "The Vagrant GANETI plugin is only compatible with Vagrant 1.2+"
+end
+
+module VagrantPlugins
+  module GANETI
+    class Plugin < Vagrant.plugin("2")
+      name "GANETI"
+      description <<-DESC
+      This plugin installs a provider that allows Vagrant to manage
+      machines in GANETI clusters.
+      DESC
+
+      config(:ganeti, :provider) do
+        require_relative "config"
+        Config
+      end
+
+      provider(:ganeti, parallel: true) do
+        # Setup logging and i18n
+        setup_logging
+        setup_i18n
+
+        # Return the provider
+        require_relative "provider"
+        Provider
+      end
+
+      # This initializes the internationalization strings.
+      def self.setup_i18n
+        I18n.load_path << File.expand_path("locales/en.yml", GANETI.source_root)
+        I18n.reload!
+      end
+
+      # This sets up our log level to be whatever VAGRANT_LOG is.
+      def self.setup_logging
+        require "log4r"
+
+        level = nil
+        begin
+          level = Log4r.const_get(ENV["VAGRANT_LOG"].upcase)
+        rescue NameError
+          # This means that the logging constant wasn't found,
+          # which is fine. We just keep `level` as `nil`. But
+          # we tell the user.
+          level = nil
+        end
+
+        # Some constants, such as "true" resolve to booleans, so the
+        # above error checking doesn't catch it. This will check to make
+        # sure that the log level is an integer, as Log4r requires.
+        level = nil if !level.is_a?(Integer)
+
+        # Set the logging level on all "vagrant" namespaced
+        # logs as long as we have a valid level.
+        if level
+          logger = Log4r::Logger.new("vagrant_plugin_ganeti")
+          logger.outputters = Log4r::Outputter.stderr
+          logger.level = level
+          logger = nil
+        end
+      end
+    end
+  end
+end